Gry wideo Pygame

Pygame to moduł w Python używany do projektowania gier wideo; Te gry wideo wahają się od prostego tic tac palca po kosmiczne bojownicy. Niezależnie od tego, czy chcesz zaprojektować prostą grę, czy skomplikowaną, musisz zacząć od podstaw, jak działa Pygame. W tym samouczku przejrzymy podstawy Pygame, tworząc grę wideo.

Zainstaluj PyGame za pomocą:

PIP Instaluj Pygame

Krok 1: Tworzenie początkowego okna

Pierwszym krokiem w tworzeniu gry wideo jest inicjowanie Pygame za pomocą metody init (). Następnie ustawiamy geometrię ekranu za pomocą Pygame.wyświetlacz.set_mode (), gdzie przechodzimy szerokość i wysokość ekranu (w tej kolejności). Te dwa wiersze kodu utworzą okno, które szybko znikną, więc potrzebujemy MainLoop, aby utrzymać działanie okna. W ramach tego MainLoop dodamy strategię wyjścia. Strategia wyjścia jest tworzona przez wybór wydarzenia z listy wydarzeń (ta lista wydarzeń leży w Pygame.wydarzenie.get (), które kryją wszystkie dostępne wydarzenia). Następnie stwierdzamy, że jeśli zdarzenie, które wybraliśmy, to Pygame.Rzuć, a następnie wyjdź. Ten ostatni utworzy MainLoop dla okna, który utrzyma okno działanie, aż naciśnij przycisk wyjścia.

Import Pygame
Import Sys
Pygame.w tym()
Rozmiar = szerokość, wysokość = 800, 600
Ekran = Pygame.wyświetlacz.set_mode (rozmiar)
Choć prawda:
na wydarzenie w Pygame.wydarzenie.Dostawać():
Jeśli zdarzenie.Type == Pygame.ZREZYGNOWAĆ:
Sys.Wyjście()

Krok 2: Dodanie tytułów, ikon, kolorów tła i obrazów

W tej sekcji dodamy tytuły, kolory tła i obrazy oraz ikony do okna.

(a) Tytuł jest dodawany za pomocą:

# Ustaw tytuł okna
Pygame.wyświetlacz.set_caption („gra wideo”)

(b) Mam swoje logo z https: // icons8.com/icon/set/computer-hardware/doodle. Jeśli używasz PYCharm, umieść ikonę pobieraną w odpowiednim folderze (w moim przypadku był to C: \ Users \ Never \ pycharmprojects \ pythonproject2 \ icon.PNG). Logo jest dodawane za pomocą:

# Ustaw ikonę
Image = Pygame.obraz.ładowanie („Ikona.png ")
Pygame.wyświetlacz.set_icon (obraz)

(c) Możesz także zmienić kolor backgound. W tym celu używamy ekranu.wypełnienie (), który ma kolor RGB. W moim przypadku ustawiłem to na (0,0,0). Po ustawieniu koloru musisz również zaktualizować Pygame, aby zmienić kolor, aby się obowiązywać.

# Wypełnij tło
ekran.Wypełnij ((0, 0, 0))
Pygame.wyświetlacz.aktualizacja()

(d) Co jeśli chcesz ustawić zdjęcie tła na ekranie? To jest również możliwe. Ponieważ chcesz, aby obraz działał przez cały czas, musi być umieszczony w pętli While. W rzeczywistości wszystko, co musi działać stale, musi być umieszczone w MainLoop. Używamy Pygame.obraz.załaduj (), aby wybrać zdjęcie, które chcemy załadować, oraz metodę BLIT (), aby go umieścić. Tutaj ekran.Blit () bierze dwa argumenty - załadowany obraz, krotek lokalizacji, w którym zostanie umieszczony górny narożnik obrazu. Ponadto Pygame.wyświetlacz.aktualizacja () należy umieścić na samym końcu, aby zaktualizować ekran! Podczas projektowania gier wideo kolejność kodu ma znaczenie!!! Na przykład aktualizacja nie może nadejść przed zdjęciami!

# Utwórz obraz tła
BG_IMAGE = PYGAME.obraz.Załaduj („BG_IMAGE.jpg ")
ekran.BLIT (BG_IMAGE, (-15, -25))
Pygame.wyświetlacz.aktualizacja()

Alternatywnie możemy również zrzucić go do funkcji tła (która będzie przydatna później), więc przepisujemy tło w następujący sposób:

# Utwórz obraz tła
BG_IMAGE = PYGAME.obraz.Załaduj („BG_IMAGE_3.jpg ")
def tle ():
ekran.BLIT (BG_IMAGE, (-15, -25))

Należy pamiętać, że umieściliśmy tło w funkcji o nazwie Time (), którą aktywujemy w pętli While Później.

Krok 3: Dodanie obrazów odtwarzacza do okna

Następnie stwórzmy osobę. Odbywa się to poprzez najpierw załadowanie obrazu, a następnie za pomocą ekranu.Blit () do umieszczenia obrazu.

# Zdjęcie osoby
image_person = pygame.obraz.Ładuj („Osoba.png ")
ekran.Blit (image_person, (400, 550))

Należy pamiętać, że zamówienie kodu również ma znaczenie! Jeśli umieścisz kod tła po kodzie dla wroga, ani osoba, ani wroga nie będą widoczne!

Jednak po raz kolejny w celu całego kodu umieścimy go w funkcji. Kod można więc ponownie napisać w następujący sposób:

# Zdjęcie osoby
person_x = 400
person_y = 550
image_person = pygame.obraz.Ładuj („Dziewczyna.png ")
def Person (x, y):
ekran.Blit (image_person, (x, y))

Ta funkcja może być aktywowana w pętli While w następujący sposób:

osoba (osobista, person_y)

Krok 4: Ruch Person ()

Teraz robi się trudne, więc zwróć uwagę. Musimy nacisnąć klawisze, aby przesunąć osobę w prawo, więc wprowadzimy ją do pętli While w następujący sposób:

pressed_keys = pygame.klucz.get_pressed ()
Jeśli naciśnięte_keys [Pygame.K_right]:
person_x += 0.1
Jeśli naciśnięte_keys [Pygame.K_left]:
person_x += -0.1

Używamy Pygame.klucz.get_pressed (), aby uzyskać naciśnięty klawisz, a następnie sprawdź go. Jeśli naciśnięty klawisz jest prawym klawiszem strzałki (Pygame.K_right), wówczas nasza zmienna osobista jest zwiększana o wartość 0.1. Jeśli z drugiej strony, naciśnięty klawisz jest lewą strzałą (Pygame.K_left), a następnie zmniejszamy o 0.1. To, co robimy, to zmiana lokalizacji obrazu na konsoli. Jeśli wciśnię prawą strzałkę, stanie się początkowa krotek (400, 550) (400.1, 550) - i to jest lokalizacja obrazu!

Musimy również aktywować obie funkcje - w tle () i person (). Funkcja tło () wyczyści ekran za każdym razem, gdy pętla się uruchomi, a bez niego będziesz mieć „przeciągnięcie”.

Kod jako całości w tym momencie wyglądałby tak:

Import Pygame
Import Sys
# Zainicjuj
Pygame.w tym()
# Ustaw geometrię ekranu
Rozmiar = szerokość, wysokość = 800, 600
Ekran = Pygame.wyświetlacz.set_mode (rozmiar)
# Ustaw tytuł okna
Pygame.wyświetlacz.set_caption („gra wideo”)
# Ustaw ikonę
Image = Pygame.obraz.ładowanie („Ikona.png ")
Pygame.wyświetlacz.set_icon (obraz)
# Utwórz obraz tła
BG_IMAGE = PYGAME.obraz.Załaduj („BG_IMAGE_3.jpg ")
def tle ():
ekran.BLIT (BG_IMAGE, (-15, -25))
# Zdjęcie osoby
person_x = 400
person_y = 550
image_person = pygame.obraz.Ładuj („Dziewczyna.png ")
def Person (x, y):
ekran.Blit (image_person, (x, y))
# główna pętla
Choć prawda:
na wydarzenie w Pygame.wydarzenie.Dostawać():
Jeśli zdarzenie.Type == Pygame.ZREZYGNOWAĆ:
Sys.Wyjście()
# Sprawdź naciśnięte klucze
pressed_keys = pygame.klucz.get_pressed ()
# Jeśli naciśnięty klawisz jest prawą strzałką,
# Następnie przejdź w prawo
Jeśli naciśnięte_keys [Pygame.K_right]:
person_x += 0.1
# Jeśli naciśniętym klawiszem jest lewa strzałka,
# następnie przesuń się w lewo
Jeśli naciśnięte_keys [Pygame.K_left]:
person_x += -0.1
# aktywuj funkcję tła
tło()
# aktywuj funkcję osoby
osoba (osobista, person_y)
# Zaktualizuj wszystko
Pygame.wyświetlacz.aktualizacja()

Krok 5: Ustaw granice graniczne

Po naciśnięciu prawego lub lewego klawisza strzałki, w tej chwili osoba (lub główna bohater) w naszej grze będzie się poruszać i przesuwać nawet poza zasięgiem lub poza oknem konsoli. Następną rzeczą, którą musimy zrobić, jest ustalenie ograniczeń ruchu.

Ustawienie limitów jest łatwe. Idziemy do naszych prasowych_keys [Pygame.K_right] argument i dodaj warunek. Dodajemy warunek, że x musi być mniej niż szerokość naszego ekranu - szerokość postaci.

W moim przypadku szerokość postaci wynosiła 50 pikseli, a szerokość X mojego ekranu wynosiła 800. Więc ustawiłem prawą stronę na 800 - 50 = 750 pikseli. Ogranicza to ruch mojej postaci. Moja postać nie może wykraczać poza 750 pikseli, a zatem pozostanie na ekranie konsoli.

pressed_keys = pygame.klucz.get_pressed ()
# Jeśli naciśnięty klawisz jest prawą strzałką,
# Następnie przejdź w prawo
Jeśli naciśnięte_keys [Pygame.K_right] i person_x < 750:
person_x += 0.1
# Jeśli naciśniętym klawiszem jest lewa strzałka,
# następnie przesuń się w lewo
Jeśli naciśnięte_keys [Pygame.K_LEFT] i osobowość_x> 0:
person_x += -0.1

Krok 6: Tworzenie wroga

Tworzenie wroga jest łatwą częścią. Robimy to w taki sam sposób, w jaki stworzyliśmy główny bohater. Tutaj chcielibyśmy losować lokalizację, w której pojawia się wróg, więc użyjemy modułu losowego, aby to zrobić. Używamy losowych.Randint (), aby ustawić losową lokalizację.

Import losowy
# Obraz wroga
wrogowie_x = losowe.Randint (0, 750)
wrogowie_y = losowe.Randint (0, 300)
image_enemy = pygame.obraz.Ładowanie („Wróg.png ")
def wroga (x, y):
ekran.Blit (image_enemy, (x, y))

Pamiętaj, aby aktywować wroga w pętli While:

# aktywuj wroga
wrogi (wrogowy_x, wrogi_y)

Krok 7: Poruszanie wroga

Przeniesienie wroga wymaga trochę wyobraźni. Zainicjujemy zmienne (poza pętlą While):

#Initializuj zmienne
wrogowie_diff = 0.6
wrogowie_x = 0

A w pętli While piszemy:

# Przenieś wroga
wrogowie_x += wrogowie_diff
Jeśli wrogowie_x <= 0:
wrogowie_x = 0
wrogowie_diff = 0.6
Jeśli wrogi_x> = 730:
wrogowie_x = 730
wrogowie_diff = -0.6

To robi, że jeśli obraz wroga znajduje się w granicach (w tym przypadku między 0 a 730), obliczy równanie wrogów_x = wrogowie_x + wrog_diff i porusza go. Jeśli z drugiej strony lokalizacja wroga jest większa niż 730, wówczas ustawiamy lokalizację wroga_xx na 730 i odwrócimy prędkość, pisząc -0.6 zamiast 0.6. Jeśli lokalizacja wroga jest mniejsza niż 0, wówczas ustawiamy zmienną wroga_x na 0 i mówimy, aby poszedł do przodu o 0.6 pikseli. Ponieważ mamy do czynienia z pętlą, za każdym razem, gdy pętla zaczyna się od nowa, powoduje zmianę zmiennej wroga, a zatem położenie wroga. Ostatecznie wszystko to zrobi, to na zawsze przesunąć wroga w lewo iw tył.

Krok 8: Tworzenie i strzelanie do wielu pocisków

W moim przypadku zamierzam rzucić książki w kulę ognia. Więc moja kula to książka lub wiele książek. Najpierw zainicjujmy wszystkie potrzebne zmienne:

#Initializuj zmienne
Books_diff = 4
Books_y = 520
Books_X = 420

Books_X i Books_Y są ich początkową lokalizacją; Umieściłem je w pobliżu głównego bohatera. Books_diff to jego prędkość. Następnie zainicjujemy jego stan, który „nie porusza się” i ładujemy obraz.

# Książki obraz
Books_State = „Nie przeprowadzka”
image_books = pygame.obraz.ładowanie („Książki.png ")

Następnie tworzymy funkcję, która przyjmuje Books_State. Jeśli umieścimy książkę na siatce, zmieniamy jej stan na „przeprowadzkę”. Ta funkcja jest główną funkcją, która umieści kulę na mapie/konsoli. Ponadto w Funkcjach () napisałem x+15 i y+1, aby wyśrodkować obraz. Bez tych ostatnich książki patrzą na jedną stronę.

Def Books (x, y):
Global Books_State
Books_State = „Moving”
ekran.Blit (image_books, (x + 15, y + 1))

I w głównej pętli napisałbyś:

# Ruch książek
Jeśli książki_y <= 0:
Books_y = 420
Books_State = „Nie przeprowadzka”
Jeśli książki_state „porusza się”:
Books_X = osobis_x
Książki (Books_X, Books_Y)
Books_Y -= Books_diff
# Zwolnij, jeśli przycisk przestrzeni zostanie naciśnięty
Jeśli naciśnięte_keys [Pygame.K_space]:
Books_X = osobis_x
Książki (Books_X, Books_Y)

Najpierw definiujemy, co się stanie, gdy kule/książki odsuwają się z siatki lub są na pozycji y<0. In this case, we change the state back to “not moving” and place the books back on the y-axis at 420. If, on the other hand, the state of the book is “moving”, we say that we want it to move (books_y -= books_diff where books_diff is its speed). Next, we also state that if the key is pressed, we want the books() function to be activated, placing the books' image onto the console grid.

W tym momencie kod jako całość wyglądałby mniej więcej tak:

Import Pygame
Import Sys
# Zainicjuj
Pygame.w tym()
# Zainicjuj zegar
zegar = Pygame.czas.Zegar()
# Ustaw geometrię ekranu
Rozmiar = szerokość, wysokość = 800, 600
Ekran = Pygame.wyświetlacz.set_mode (rozmiar)
# Ustaw tytuł okna
Pygame.wyświetlacz.set_caption („gra wideo”)
# Ustaw ikonę
Image = Pygame.obraz.ładowanie („Ikona.png ")
Pygame.wyświetlacz.set_icon (obraz)
# Utwórz obraz tła
BG_IMAGE = PYGAME.obraz.Załaduj („BG_IMAGE_3.jpg ")
def tle ():
ekran.BLIT (BG_IMAGE, (-15, -25))
# Zdjęcie osoby
person_x = 400
person_y = 550
image_person = pygame.obraz.Ładuj („Dziewczyna.png ")
def Person (x, y):
ekran.Blit (image_person, (x, y))
Import losowy
# Obraz wroga
wrogowie_x = losowe.Randint (0, 750)
wrogowie_y = losowe.Randint (0, 300)
image_enemy = pygame.obraz.Ładowanie („Wróg.png ")
def wroga (x, y):
ekran.Blit (image_enemy, (x, y))
#Initializuj zmienne wroga
wrogowie_diff = 0.6
wrogowie_x = 0
#Initializuj zmienne
Books_diff = 4
Books_y = 520
Books_X = 420
# Książki obraz
Books_State = „Nie przeprowadzka”
image_books = pygame.obraz.ładowanie („Książki.png ")
Def Books (x, y):
Global Books_State
Books_State = „Moving”
ekran.Blit (image_books, (x + 15, y + 1))
# główna pętla
Choć prawda:
na wydarzenie w Pygame.wydarzenie.Dostawać():
Jeśli zdarzenie.Type == Pygame.ZREZYGNOWAĆ:
Sys.Wyjście()
# Sprawdź naciśnięte klucze
pressed_keys = pygame.klucz.get_pressed ()
# Jeśli naciśnięty klawisz jest prawą strzałką,
# Następnie przejdź w prawo
Jeśli naciśnięte_keys [Pygame.K_right] i person_x < 750:
person_x += 0.8
# Jeśli naciśniętym klawiszem jest lewa strzałka,
# następnie przesuń się w lewo
Jeśli naciśnięte_keys [Pygame.K_LEFT] i osobowość_x> 0:
person_x += -0.8
# aktywuj funkcję tła
tło()
# aktywuj funkcję osoby
osoba (osobista, person_y)
# Przenieś wroga
wrogowie_x += wrogowie_diff
Jeśli wrogowie_x <= 0:
wrogowie_x = 0
wrogowie_diff = 0.6
Jeśli wrogi_x> = 730:
wrogowie_x = 730
wrogowie_diff = -0.6
# Ruch książek
Jeśli książki_y <= 0:
Books_y = 420
Books_State = „Nie przeprowadzka”
Jeśli książki_state „porusza się”:
Books_X = osobis_x
Książki (Books_X, Books_Y)
Books_Y -= Books_diff
# Zwolnij, jeśli przycisk przestrzeni zostanie naciśnięty
Jeśli naciśnięte_keys [Pygame.K_space]:
Books_X = osobis_x
Książki (Books_X, Books_Y)
# aktywuj wroga
wrogi (wrogowy_x, wrogi_y)
# Zaktualizuj wszystko
Pygame.wyświetlacz.aktualizacja()
zegar.klesz (60)

Ten kod nakręci wiele książek po drugiej po naciśnięciu klawisza przestrzeni.

Krok 9: Wykrywanie zderzenia

Następnym krokiem jest wykrycie zderzenia, a to wydaje się dość proste. Użyłbyś Pygame.Rect (x, y, szerokość, wysokość), aby zdefiniować prostokąt. Następnie użyj metody Colliderect (), aby wykryć kolizję między dwoma prostokątami. Mówimy również, że jeśli wykryje kolizję, zwiększamy wynik o 1, ponownie zlokalizujemy wroga i usuwamy kulę, resetując go.

# wykrywanie kolizji
wrogowie_rect = pygame.Rect (wrogowy_x, wrogi_y, 64, 64)
Books_Rect = Pygame.Rect (Books_X, Books_Y, 64, 64)
Jeśli książki_rect.Colderect (wrogowy_rect):
wrogowie_x = losowe.Randrange (0, 800)
wrogowie_y = losowe.Randrange (0, 300)
wynik += 1
BULLET_STATE = „Nie poruszaj się”
wrogi (wrogowy_x, wrogi_y)
Books_y = 0

Krok 10: Wyświetlanie tekstu

Poza MainLoopem napisałbyś:

wynik = 0
#Initializuj czcionkę
Pygame.czcionka.w tym()
myFont = Pygame.czcionka.Sysfont („Comic Sans MS”, 50)
def Text_Score (x, y):
Text_Score = myFont.render („wynik:”+ str (wynik), true, (0, 0, 0))
ekran.Blit (text_score, (x, y))

W głównej pętli napisałbyś:

# Aktywuj wynik tekstowy
Text_Score (6, 6)

Tutaj czcionki należy zainicjować, więc zainicjuj je za pomocą Pygame.czcionka.w tym(). Następnie wybierasz czcionkę za pomocą Pygame.czcionka.Sysfont (), w którym mijasz czcionkę i rozmiar. Następnie zdefiniujmy funkcję, w której używamy metody renderowania, aby ją renderować. Tutaj, ponieważ wynik jest liczbą całkowitą, używamy STR (wynik). A następnie umieszczamy je na ekranie za pomocą metody BLIT ().

W tym momencie cały kod wyglądałby tak:

Import Pygame
Import Sys
# Zainicjuj
Pygame.w tym()
# Zainicjuj zegar
zegar = Pygame.czas.Zegar()
# Ustaw geometrię ekranu
Rozmiar = szerokość, wysokość = 800, 600
Ekran = Pygame.wyświetlacz.set_mode (rozmiar)
# Ustaw tytuł okna
Pygame.wyświetlacz.set_caption („gra wideo”)
# Ustaw ikonę
Image = Pygame.obraz.ładowanie („Ikona.png ")
Pygame.wyświetlacz.set_icon (obraz)
# Utwórz obraz tła
BG_IMAGE = PYGAME.obraz.Załaduj („BG_IMAGE_3.jpg ")
def tle ():
ekran.BLIT (BG_IMAGE, (-15, -25))
# Zdjęcie osoby
person_x = 400
person_y = 550
image_person = pygame.obraz.Ładuj („Dziewczyna.png ")
def Person (x, y):
ekran.Blit (image_person, (x, y))
Import losowy
# Obraz wroga
wrogowie_x = losowe.Randint (0, 750)
wrogowie_y = losowe.Randint (0, 300)
image_enemy = pygame.obraz.Ładowanie („Wróg.png ")
def wroga (x, y):
ekran.Blit (image_enemy, (x, y))
#Initializuj zmienne wroga
wrogowie_diff = 0.6
wrogowie_x = 0
#Initializuj zmienne
Books_diff = 4
Books_y = 520
Books_X = 420
# Książki obraz
Books_State = „Nie przeprowadzka”
image_books = pygame.obraz.ładowanie („Książki.png ")
Def Books (x, y):
Global Books_State
Books_State = „Moving”
ekran.Blit (image_books, (x + 15, y + 1))
wynik = 0
#Initializuj czcionkę
Pygame.czcionka.w tym()
myFont = Pygame.czcionka.Sysfont („Comic Sans MS”, 50)
def Text_Score (x, y):
Text_Score = myFont.render („wynik:”+ str (wynik), true, (0, 0, 0))
ekran.Blit (text_score, (x, y))
# główna pętla
Choć prawda:
na wydarzenie w Pygame.wydarzenie.Dostawać():
Jeśli zdarzenie.Type == Pygame.ZREZYGNOWAĆ:
Sys.Wyjście()
# Sprawdź naciśnięte klucze
pressed_keys = pygame.klucz.get_pressed ()
# Jeśli naciśnięty klawisz jest prawą strzałką,
# Następnie przejdź w prawo
Jeśli naciśnięte_keys [Pygame.K_right] i person_x < 750:
person_x += 0.8
# Jeśli naciśniętym klawiszem jest lewa strzałka,
# następnie przesuń się w lewo
Jeśli naciśnięte_keys [Pygame.K_LEFT] i osobowość_x> 0:
person_x += -0.8
# aktywuj funkcję tła
tło()
# aktywuj funkcję osoby
osoba (osobista, person_y)
# Przenieś wroga
wrogowie_x += wrogowie_diff
Jeśli wrogowie_x <= 0:
wrogowie_x = 0
wrogowie_diff = 0.6
Jeśli wrogi_x> = 730:
wrogowie_x = 730
wrogowie_diff = -0.6
# Ruch książek
Jeśli książki_y <= 0:
Books_y = 420
Books_State = „Nie przeprowadzka”
Jeśli książki_state „porusza się”:
Books_X = osobis_x
Książki (Books_X, Books_Y)
Books_Y -= Books_diff
# Zwolnij, jeśli przycisk przestrzeni zostanie naciśnięty
Jeśli naciśnięte_keys [Pygame.K_space]:
Books_X = osobis_x
Książki (Books_X, Books_Y)
# aktywuj wroga
wrogi (wrogowy_x, wrogi_y)
# wykrywanie kolizji
wrogowie_rect = pygame.Rect (wrogowy_x, wrogi_y, 64, 64)
Books_Rect = Pygame.Rect (Books_X, Books_Y, 64, 64)
Jeśli książki_rect.Colderect (wrogowy_rect):
wrogowie_x = losowe.Randrange (0, 800)
wrogowie_y = losowe.Randrange (0, 300)
wynik += 1
BULLET_STATE = „Nie poruszaj się”
wrogi (wrogowy_x, wrogi_y)
Books_y = 0
# Aktywuj wynik tekstowy
Text_Score (6, 6)
# Zaktualizuj wszystko
Pygame.wyświetlacz.aktualizacja()
zegar.klesz (60)

Krok 11: Dodawanie dźwięków

Dodawanie dźwięków jest super duper łatwe!

Poza główną pętlą napiszesz:

# Zainicjuj dźwięki
Pygame.mikser.w tym()
Pygame.mikser.muzyka.Ładowanie („Kocowanie broni-01.WAV ")

W MainLoop zamierzam aktywować dźwięk, jeśli jest kolizja! Tutaj używamy Pygame.mikser.muzyka.grać().

# wykrywanie kolizji
wrogowie_rect = pygame.Rect (wrogowy_x, wrogi_y, 64, 64)
Books_Rect = Pygame.Rect (Books_X, Books_Y, 64, 64)
Jeśli książki_rect.Colderect (wrogowy_rect):
wrogowie_x = losowe.Randrange (0, 800)
wrogowie_y = losowe.Randrange (0, 300)
wynik += 1
BULLET_STATE = „Nie poruszaj się”
wrogi (wrogowy_x, wrogi_y)
Books_y = 0
Pygame.mikser.muzyka.grać()

Krok 12: Zakończenie gry

Zamierzam wygrać tę grę, jeśli wynik jest większy niż 5. Więc poza główną pętlą piszemy następujący kod:

text_game_over = pygame.czcionka.Sysfont („Comic Sans MS”, 80)
# gra nad funkcją
def game_over (x, y):
text_game_over_2 = myFont.render („wygrałeś”, true, (0, 0, 0))
ekran.blit (text_game_over_2, (x, y))

I w głównej pętli napisałbyś:

# Sprawdź wygraną
Jeśli wynik> 5:
Game_over (400, 300)
Pygame.wyświetlacz.trzepnięcie()
czas.sen (5)
przerwa
# Aktywuj wynik tekstowy
Text_Score (6, 6)
Timer (500, 6)

Oznacza to, że jeśli wynik jest większy niż 5, wówczas funkcja game_over () zostanie aktywowana, ekran zostanie odświeżony, a następnie mówimy: spać przez chwilę przed paleniem.

Cały kod wyglądałby tak:

Import Pygame
Import Sys
czas importu
# Zainicjuj
Pygame.w tym()
# Zainicjuj zegar
zegar = Pygame.czas.Zegar()
# Ustaw geometrię ekranu
Rozmiar = szerokość, wysokość = 800, 600
Ekran = Pygame.wyświetlacz.set_mode (rozmiar)
# Ustaw tytuł okna
Pygame.wyświetlacz.set_caption („gra wideo”)
# Ustaw ikonę
Image = Pygame.obraz.ładowanie („Ikona.png ")
Pygame.wyświetlacz.set_icon (obraz)
# Utwórz obraz tła
BG_IMAGE = PYGAME.obraz.Załaduj („BG_IMAGE_3.jpg ")
def tle ():
ekran.BLIT (BG_IMAGE, (-15, -25))
# Zdjęcie osoby
person_x = 400
person_y = 550
image_person = pygame.obraz.Ładuj („Dziewczyna.png ")
def Person (x, y):
ekran.Blit (image_person, (x, y))
Import losowy
# Obraz wroga
wrogowie_x = losowe.Randint (0, 750)
wrogowie_y = losowe.Randint (0, 300)
image_enemy = pygame.obraz.Ładowanie („Wróg.png ")
def wroga (x, y):
ekran.Blit (image_enemy, (x, y))
#Initializuj zmienne wroga
wrogowie_diff = 0.6
wrogowie_x = 0
#Initializuj zmienne
Books_diff = 4
Books_y = 520
Books_X = 420
# Książki obraz
Books_State = „Nie przeprowadzka”
image_books = pygame.obraz.ładowanie („Książki.png ")
Def Books (x, y):
Global Books_State
Books_State = „Moving”
ekran.Blit (image_books, (x + 15, y + 1))
wynik = 0
#Initializuj czcionkę
Pygame.czcionka.w tym()
myFont = Pygame.czcionka.Sysfont („Comic Sans MS”, 50)
def Text_Score (x, y):
Text_Score = myFont.render („wynik:”+ str (wynik), true, (0, 0, 0))
ekran.Blit (text_score, (x, y))
# Zainicjuj dźwięki
Pygame.mikser.w tym()
Pygame.mikser.muzyka.Ładowanie („Kocowanie broni-01.WAV ")
text_game_over = pygame.czcionka.Sysfont („Comic Sans MS”, 80)
# gra nad funkcją
def game_over (x, y):
text_game_over_2 = myFont.render („wygrałeś”, true, (0, 0, 0))
ekran.blit (text_game_over_2, (x, y))
def Timer (x, y):
Text_timer = myFont.render („czas:”+ str (Pygame.czas.get_ticks ()), true, (0, 0, 0))
ekran.Blit (text_timer, (x, y))
# główna pętla
Choć prawda:
na wydarzenie w Pygame.wydarzenie.Dostawać():
Jeśli zdarzenie.Type == Pygame.ZREZYGNOWAĆ:
Sys.Wyjście()
# Sprawdź naciśnięte klucze
pressed_keys = pygame.klucz.get_pressed ()
# Jeśli naciśnięty klawisz jest prawą strzałką,
# Następnie przejdź w prawo
Jeśli naciśnięte_keys [Pygame.K_right] i person_x < 750:
person_x += 0.8
# Jeśli naciśniętym klawiszem jest lewa strzałka,
# następnie przesuń się w lewo
Jeśli naciśnięte_keys [Pygame.K_LEFT] i osobowość_x> 0:
person_x += -0.8
# aktywuj funkcję tła
tło()
# aktywuj funkcję osoby
osoba (osobista, person_y)
# Przenieś wroga
wrogowie_x += wrogowie_diff
Jeśli wrogowie_x <= 0:
wrogowie_x = 0
wrogowie_diff = 0.6
Jeśli wrogi_x> = 730:
wrogowie_x = 730
wrogowie_diff = -0.6
# Ruch książek
Jeśli książki_y <= 0:
Books_y = 420
Books_State = „Nie przeprowadzka”
Jeśli książki_state „porusza się”:
Books_X = osobis_x
Książki (Books_X, Books_Y)
Books_Y -= Books_diff
# Zwolnij, jeśli przycisk przestrzeni zostanie naciśnięty
Jeśli naciśnięte_keys [Pygame.K_space]:
Books_X = osobis_x
Książki (Books_X, Books_Y)
# aktywuj wroga
wrogi (wrogowy_x, wrogi_y)
# wykrywanie kolizji
wrogowie_rect = pygame.Rect (wrogowy_x, wrogi_y, 64, 64)
Books_Rect = Pygame.Rect (Books_X, Books_Y, 64, 64)
Jeśli książki_rect.Colderect (wrogowy_rect):
wrogowie_x = losowe.Randrange (0, 800)
wrogowie_y = losowe.Randrange (0, 300)
wynik += 1
BULLET_STATE = „Nie poruszaj się”
wrogi (wrogowy_x, wrogi_y)
Books_y = 0
Pygame.mikser.muzyka.grać()
# Sprawdź wygraną
Jeśli wynik> 5:
Game_over (400, 300)
Pygame.wyświetlacz.trzepnięcie()
czas.sen (5)
przerwa
# Aktywuj wynik tekstowy
Text_Score (6, 6)
Timer (500, 6)
# Zaktualizuj wszystko
Pygame.wyświetlacz.aktualizacja()
zegar.klesz (60)

To oczywiście najprostsze ze wszystkich gier, które możesz stworzyć! Jest to jednak początek dla tych, którzy chcą nauczyć się Pygame i zaprojektować lepsze gry wideo.

Szczęśliwa gra!