Jak zaprogramować gry na Pythonie za pomocą biblioteki Pygame

Ten artykuł jest przeznaczony dla tych, którzy są już zaznajomieni z językiem programowania Pythona i umożliwia czytanie biblioteki Pygame dla tego języka. Jako wizualny przykład pokazuje się tutaj prosty proces programowania gry, w którym gracz musi przekazać przed kącikami skokowymi.

Kroki

Część 1 z 8:

Instalowanie PYGAME

jeden. Pobierz Pygame. Postępuj zgodnie z linkiem i znajdź wersję biblioteki odpowiedniej dla swojej platformy: http: // PYGAME.Org / Download.shtml .

2. Uruchom instalator.

3. Upewnij się, że instalacja zakończy się pomyślnie. Otwórz terminal Pythona. Wpisz "Importuj Pygame". Jeśli pojawiają się komunikaty o błędach, wtedy można pomyślnie zainstalować Pygame.

Importuj Pygame

Część 2 z 8:

Tworzenie głównego okna gry

jeden. Utwórz nowy plik.

2. Importuj Pygame. Pygame to biblioteka, która implementuje dostęp do funkcji graficznych programowania Pythona. Jeśli chcesz dowiedzieć się więcej o tym, jak te funkcje działają, informacje są dostępne na Pygame. https: // PYGAME.Org / docs /

Importuj PygameFrom Pygame.Importuj mieszkańcy *

3. Określ rozmiar okna gry. Utwórz zmienną globalną dla rozmiarów okien, aby odnieść się do niej z różnych części gry. Dla wygody te parametry są lepsze do określenia na początku pliku, więc jeśli to konieczne, było łatwiejsze do zmiany w przyszłości. Aby uzyskać bardziej złożone projekty, będzie korzystniejsze, aby dokonać takich danych w oddzielnym pliku.

Rozdzielczość = (400 300)

cztery. Określ kilka kolorów. Kolory w pigamie są zdefiniowane w formacie RGBA w zakresie od 0 do 255. Wartość alfa (A) można pominąć, ale reszta kolorów (czerwona, zielona i niebieska) jest wymagana do napełniania.

Biały = (255,255555) Black = (0.0.0) Red = (255.0.0)

pięć. Zainicjuj główny ekran. Użyj wcześniejszej zmiennej rozdzielczości zdefiniowanej wcześniej.

Ekran = Pygame.Pokaz.Set_mode (rozdzielczość)

6. Utwórz cykl gry. Ustaw powtórzenie pewnych działań w każdej klapie gry. Utwórz cykl, który konsekwentnie wykonuje wszystkie te działania.

PRAWDA:

7. Określ kolor wypełnienia ekranu.

Ekran.Wypełnić (biały)

osiem. Wyświetl ekran. Jeśli uruchomisz program na tym etapie, ekran jest pomalowany na biało, a następnie program zatrzyma się w nagłych wypadkach. Przyczyną awarii będzie, że system operacyjny wysyła zdarzenia programu, a program po prostu nie kontynuuje. Gdy program gromadzi zbyt wiele nietraktowanych zdarzeń, awaria powstaje awaria.

PRAWDA:...PYGAME.Pokaz.Flip ()

dziewięć. Wdrożyć przetwarzanie zdarzeń. Uzyskaj listę wszystkich zdarzeń, które powstały między ramkami rysunkowymi. W naszym przykładzie należy się martwić o przetwarzanie tylko jednego zdarzenia wyjściowego (QUIT). Występuje, gdy użytkownik zamyka okno gry. Przetwarzanie zdarzeń zapobiegnie awarie programu z wyglądu zbyt wiele zdarzeń.

PRAWDA:...W przypadku wydarzenia w Pygame.Zdarzenie.Get (): jeśli wydarzenie.Typ == QUIT: PYGAME.porzucić ()

Obraz zatytułowany programisGamepart1.jpg

10. Wypróbuj program! Teraz kod programu powinien wyglądać tak:

Importuj PygameFrom Pygame.Liczba Importuj * Rozdzielczość = (400,300) White = (255,255255) Black = (0.0.0) Red = (255,0,0) Ekran = Pygame.Pokaz.Set_mode (rozdzielczość) podczas true: ekran.Wypełnij (biały) pigame.Pokaz.Flip () na zdarzenie w Pygame.Zdarzenie.Get (): jeśli wydarzenie.Typ == QUIT: PYGAME.porzucić ()

Część 3 z 8:

Tworzenie obiektów gry

jeden. Utwórz nową klasę obiektów i jego projektanta. Ustaw wszystkie właściwości obiektu. Zdefiniuj również wartości domyślne dla każdej właściwości.

Klasa Kula: Def __init __ (Self, XPO = Rozdzielczość [0] / 2, YPO = Rozdzielczość [1] / 2, Xvel = 1, Yvel = 1, Rad = 15):.x = xposself.Y = yposself.Dx = xveelfelf.Dy = Yvielnia.Radius = Redself.Typ = "Piłka"

2. Określ rysunek obiektu. Użyj właściwości obiektów określonych w konstruktorze, aby przedstawić piłkę jako okrąg na powierzchni przekazywanej do funkcji do funkcji. Powierzchnia będzie ekranem utworzonym wcześniej, definiując jego wymiary.

Def Draw (Self, Powierzchnia): Pygame.Remis.Koło (powierzchnia, czarna, (jaźń.X, jaźń.y), ja.PROMIEŃ)

3. Utwórz instancję klasy i dodaj zadanie do cyklu gry, aby narysować piłkę w każdej iteracji cyklu.

Piłka = piłka () podczas prawda:...Piłka.Rysować (ekran)

cztery. Spraw, aby obiekt poruszył się. Utwórz funkcję, która aktualizuje pozycję obiektu. Zadzwoń do tej funkcji w każdej iteracji cyklu.

Klasa Piłka:...Def Update (Self): Self.X + = jaźń.Dself.Y + = self.Dy

pięć. Częstotliwość limitu ramy. Piłka będzie bardzo szybko poruszyć, ponieważ cykl gry jest powtarzany setki razy na sekundę. Użyj timera Pygame, aby ograniczyć częstotliwość zmiany ramki do 60 fps.

Zegar = Pygame.Czas.Zegar () podczas prawdziwych:...ZEGAR.Zaznacz (60)

Trzymaj miskę na ekranie. Dodaj kontrole do funkcji aktualizacji stanu, aby zmienić kierunek ruchu piłki, jeśli osiągnie granice ekranu.

Klasa Piłka:...Def Update (Self):...Jeśli (jaźń.X <= 0 or self.x >= Rozdzielczość [0]): Jaźń.Dx * = -1if (ja.y <= 0 or self.y >= Rozdzielczość [1]): Self.DY * = -1

Wypróbuj program! Teraz kod programu powinien wyglądać tak:

Obraz zatytułowany programisGamepart2.jpg

Importuj PygameFrom Pygame.Liczba Importuj * Rozdzielczość = (400,300) White = (255,255255) Black = (0.0.0) Red = (255,0,0) Ekran = Pygame.Pokaz.Set_mode (rozdzielczość) Klasa: Def __init __ (Self, XPO = Rozdzielczość [0] / 2, YPO = Rozdzielczość [1] / 2, Xvel = 1, Yvel = 1, Rad = 15):.x = xposself.Y = yposself.Dx = xveelfelf.Dy = Yvielnia.Radius = Redself.Typ = "Piłka"Def Draw (Self, Powierzchnia): Pygame.Remis.Koło (powierzchnia, czarna, (jaźń.X, jaźń.y), ja.Promień) Def Update: Self.X + = jaźń.Dself.Y + = self.Dif (jaźń.X <= 0 or self.x >= Rozdzielczość [0]): Jaźń.Dx * = -1if (ja.y <= 0 or self.y >= Rozdzielczość [1]): Self.DY * = -1BALL = Ball () Clock = Pygame.Czas.Zegar () podczas true: ekran.Wypełnij (biała) piłka.Draw (Ekran) Piłka.Aktualizacja () Pygame.Pokaz.Zegar flip ().Zaznacz (60) W przypadku wydarzenia w Pygame.Zdarzenie.Get (): jeśli wydarzenie.Typ == QUIT: PYGAME.porzucić ()

Część 4 z 8:

Gry strukturalne

jeden. Użyj klas do strukturyzacji. W przyszłości gra stanie się bardziej złożona. Używaj technik programowania zorientowanych obiektów do kodu strukturyzacji.

2. Konwertuj cykl gry do klasy. Od chwili obecnej gry zawiera już dane, w tym obiekty gier i funkcje, ma sens, aby zastąpić cykl gry do klasy.

Gra klasowa ():

3. Dodaj projektant. Z nim zaprzeczasz kilka obiektów używanych w grze, utwórz ekran, timer i zainicjuj Pygame. Pygame należy zainicjować w celu dalszego wykorzystania takich możliwości jak tekst lub dźwięk.

Gra klasowa (): Def __init __ (Self): Pygame.W SOBIE.Ekran = Pygame.Pokaz.Set_mode (rozdzielczość).Zegar = Pygame.Czas.Zegar ()

cztery. Ustaw przetwarzanie zdarzeń w funkcji.

Gra klasowa ():...DEF Mechevents (Self): W przypadku zdarzenia w Pygame.Zdarzenie.Get (): jeśli wydarzenie.Typ == QUIT: PYGAME.porzucić ()

pięć. Zrób cykl gry z funkcją. Wywołaj funkcję przetwarzania zdarzeń w każdej iteracji cyklu.

Gra klasowa ():...DEF Run (Self): Podczas gdy prawdziwy: ja.Menerevents () ja.Ekran.Wypełnij (biały) ja.ZEGAR.Zaznacz (60) Pygame.Pokaz.Flip ()

6. Ustaw przetwarzanie wielu obiektów gry. Na tym etapie kod gry powoduje aktualizację i przecenianie poszczególnych obiektów w każdej ramce. W tym podejściu kod gry będzie dość nieporęczny i nieuporządkowany, zwłaszcza jeśli w grze jest wiele przedmiotów. Jest mądrzejszy, aby najpierw dodać obiekty do tablicy, a następnie zaktualizować i przerysować wszystkie obiekty w tablicy w każdej iteracji cyklu. Teraz możesz łatwo zrobić nowy obiekt w grze i określić kolejną pozycję początkową.

Gra klasy (): Def __init __ (Self):...Samego siebie.Gamebjects = [].Gamebjects.Dołącz (piłka ()).Gamebjects.Dołącz (piłka (100))...DEF Run (Self): Podczas gdy prawdziwy: ja.Menerevents () dla GAMEOBJ.GAMEOBICTS: GAMEOBJ.Aktualizacja () ja.Ekran.Wypełnij (biały) dla GAMEOBJ.GAMEOBICTS: GAMEOBJ.Narysować (jaźń.Ekran) jaźń.ZEGAR.Zaznacz (60) Pygame.Pokaz.Flip ()

Obraz zatytułowany programisGamepart3.jpg

7. Wypróbuj program! Teraz kod programu powinien wyglądać tak:

Importuj PygameFrom Pygame.Liczba Importuj * Rozdzielczość = (400,300) White = (255,255255) Black = (0.0.0) Red = (255,0,0) Ekran = Pygame.Pokaz.Set_mode (rozdzielczość) Klasa: Def __init __ (Self, XPO = Rozdzielczość [0] / 2, YPO = Rozdzielczość [1] / 2, Xvel = 1, Yvel = 1, Rad = 15):.x = xposself.Y = yposself.Dx = xveelfelf.Dy = Yvielnia.Radius = Redself.Typ = "Piłka"Def Draw (Self, Powierzchnia): Pygame.Remis.Koło (powierzchnia, czarna, (jaźń.X, jaźń.y), ja.Promień) Def Update: Self.X + = jaźń.Dself.Y + = self.Dif (jaźń.X <= 0 or self.x >= Rozdzielczość [0]): Jaźń.Dx * = -1if (ja.y <= 0 or self.y >= Rozdzielczość [1]): Self.Gra dy * = -1Class (): Def __init __ (Self): Pygame.W SOBIE.Ekran = Pygame.Pokaz.Set_mode (rozdzielczość).Zegar = Pygame.Czas.Zegar () ja.Gamebjects = [].Gamebjects.Dołącz (piłka ()).Gamebjects.Dodatek (piłka (100)) DEF Mecherevents (Self): W przypadku wydarzenia w Pygame.Zdarzenie.Get (): jeśli wydarzenie.Typ == QUIT: PYGAME.Zamknij () Def Run (Self): True: Self.Menerevents () dla GAMEOBJ.GAMEOBICTS: GAMEOBJ.Aktualizacja () ja.Ekran.Wypełnij (biały) dla GAMEOBJ.GAMEOBICTS: GAMEOBJ.Narysować (jaźń.Ekran) jaźń.ZEGAR.Zaznacz (60) Pygame.Pokaz.Gra Flip () ().BIEGAĆ ()

Część 5 z 8:

Dodawanie obiektu "gracza"

jeden. Utwórz klasę gracza i jego projektant. Musisz utworzyć kolejny koło kontrolowany przez ruch myszy. Zainicjuj swoje parametry w projektancie. Jedyną ważną wartością będzie promień.

Gracz klasy: Def __init __ (Self, Rad = 20): Self.x = sam.Y = 0.RADIUS = RAD

2. Określ rysunek obiektu gracza. Jest rysowany podobnie jak w przypadku narysowania innych obiektów gry.

Gracz klasy:...Def Draw (Self, Powierzchnia): Pygame.Remis.Koło (powierzchnia, czerwony (ja.X, jaźń.y), ja.PROMIEŃ)

3. Dodaj kontrolę myszy dla obiektu odtwarzacza. W każdej klamce gry musisz sprawdzić położenie wskaźnika myszy i odnoszą pozycję obiektu odtwarzacza z tym punktem.

Gracz klasy:...Def Update (Self): Cord = Pygame.Mysz.Get_pos () Self.X = sznur [0].Y = sznur [1]

cztery. Dodaj obiekt odtwarzacza do tablicy GameObjects. Utwórz nową instancję obiektu i dodaj go do listy GameObjects.

Gra klasy (): Def __init __ (Self):...Samego siebie.Gamebjects.Append (gracz ())

Obraz zatytułowany programisGamepart4.jpg

pięć. Wypróbuj program! Teraz kod programu powinien wyglądać tak:

Importuj PygameFrom Pygame.Liczba Importuj * Rozdzielczość = (400,300) White = (255,255255) Black = (0.0.0) Red = (255,0,0) Ekran = Pygame.Pokaz.Set_mode (rozdzielczość) Klasa: Def __init __ (Self, XPO = Rozdzielczość [0] / 2, YPO = Rozdzielczość [1] / 2, Xvel = 1, Yvel = 1, Rad = 15):.x = xposself.Y = yposself.Dx = xveelfelf.Dy = Yvielnia.Radius = Redself.Typ = "Piłka"Def Draw (Self, Powierzchnia): Pygame.Remis.Koło (powierzchnia, czarna, (jaźń.X, jaźń.y), ja.Promień) Def Update: Self.X + = jaźń.Dself.Y + = self.Dif (jaźń.X <= 0 or self.x >= Rozdzielczość [0]): Jaźń.Dx * = -1if (ja.y <= 0 or self.y >= Rozdzielczość [1]): Self.DY * = -1Class Player: Def __init __ (Self, Rad = 20): Self.x = sam.Y = 0.Radius = Redself.Typ = "Gracz"Def Draw (Self, Powierzchnia): Pygame.Remis.Koło (powierzchnia, czerwony (ja.X, jaźń.y), ja.RADIUS) Def Update (Self): Cord = Pygame.Mysz.Get_pos () Self.X = sznur [0].Y = przewód [1] Gra klasy (): Def __init __ (Self): Pygame.W SOBIE.Ekran = Pygame.Pokaz.Set_mode (rozdzielczość).Zegar = Pygame.Czas.Zegar () ja.Gamebjects = [].Gamebjects.Dołącz (gracz ()).Gamebjects.Dołącz (piłka ()).Gamebjects.Dodatek (piłka (100)) DEF Mecherevents (Self): W przypadku wydarzenia w Pygame.Zdarzenie.Get (): jeśli wydarzenie.Typ == QUIT: PYGAME.Zamknij () Def Run (Self): True: Self.Menerevents () dla GAMEOBJ.GAMEOBICTS: GAMEOBJ.Aktualizacja () ja.Ekran.Wypełnij (biały) dla GAMEOBJ.GAMEOBICTS: GAMEOBJ.Narysować (jaźń.Ekran) jaźń.ZEGAR.Zaznacz (60) Pygame.Pokaz.Gra Flip () ().BIEGAĆ ()

Część 6 z 8:

Tworzenie interakcji obiektów

jeden. Zmień funkcje aktualizacji pozycji. Aby wdrożyć interakcję obiektów, konieczne jest zapewnienie im dostępu do innych właściwości. Dodaj nowy parametr do funkcji aktualizacji, aby przenieść dane listy GAMEObjects. Parametr musi być dodany do klas gracza i funkcji piłki. Jeśli masz wiele zajęć, dziedzictwo pomoże zapisać listę parametrów tego samego.

Klasa Piłka:...Def Update (Self, GameObjects):...Gracz klasy:...Def Update (Self, GameObjects):

2. Wejdź do czeków kolizji gracza z kulkami. Wyświetl wszystkie obiekty i definiuj je wśród nich, które odnoszą się do piłek. Następnie, używając promienia obiektów i formuły do określania odległości, sprawdź, czy obiekty zderzyły się ze sobą. Sprawdź zderzenia między kółkami. Jest to główny powód, dla którego jako przykład w tej grze, postacie innej formy nie są używane.

Gracz klasy:...Def Update (Self, GameObjects):...W GAMEOBJ W GAMEOBICTS: IF GAMEOBJ.Typ == "Piłka": If (Gameobj.X - jaźń.x) ** 2 + (Gameobj.Y - ja.y) ** 2 <= (gameObj.radius + self.radius)**2:

Obraz zatytułowany programisGamepart5.jpg

3. Ustaw koniec gry, gdy kolizja gracza z piłką. Na tym etapie wyznacz drogę z gry.

Jeśli (Gameobj.X - jaźń.x) ** 2 + (Gameobj.Y - ja.y) ** 2 <= (gameObj.radius + self.radius)**2:pygame.quit()

cztery. Wypróbuj program! Teraz kod programu powinien wyglądać tak:

Importuj PygameFrom Pygame.Lokals Importuj * Rozdzielczość = (400, 300) White = (255,255,255) Black = (0,0,0) Red = (255,0,0,0) Ekran = Pygame.Pokaz.Set_mode (rozdzielczość) Klasa: Def __init __ (Self, XPO = Rozdzielczość [0] / 2, YPO = Rozdzielczość [1] / 2, Xvel = 1, Yvel = 1, Rad = 15):.x = xposself.Y = yposself.Dx = xveelfelf.Dy = Yvielnia.Radius = Redself.Typ = "Piłka"Def Draw (Self, Powierzchnia): Pygame.Remis.Koło (powierzchnia, czarna, (jaźń.X, jaźń.y), ja.RADIUS) Aktualizacja Def (Self, Gamebjects): Self.X + = jaźń.Dself.Y + = self.Dif (jaźń.X <= 0 or self.x >= Rozdzielczość [0]): Jaźń.Dx * = -1if (ja.y <= 0 or self.y >= Rozdzielczość [1]): Self.DY * = -1Class Player: Def __init __ (Self, Rad = 20): Self.x = sam.Y = 0.Radius = Redself.Typ = "Gracz"Def Draw (Self, Powierzchnia): Pygame.Remis.Koło (powierzchnia, czerwony (ja.X, jaźń.y), ja.RADIUS) Def Update (Self, GameObjects): Cord = Pygame.Mysz.Get_pos () Self.X = sznur [0].Y = sznur [1] dla GameObj w Gamebjects: jeśli GAMEOBJ.Typ == "Piłka": If (Gameobj.X - jaźń.x) ** 2 + (Gameobj.Y - ja.y) ** 2 <= (gameObj.radius + self.radius)**2:pygame.quit()class game():def __init__(self):pygame.init()self.screen = pygame.display.set_mode(resolution)self.clock = pygame.time.Clock()self.gameObjects = []self.gameObjects.append(Player())self.gameObjects.append(Ball())self.gameObjects.append(Ball(100))def handleEvents(self):for event in pygame.event.get():if event.type == QUIT:pygame.quit()def run(self):while True:self.handleEvents()for gameObj in self.gameObjects:gameObj.update(self.gameObjects)self.screen.fill(white)for gameObj in self.gameObjects:gameObj.draw(self.screen)self.clock.tick(60)pygame.display.flip()game().run()

Część 7 z 8:

Dodawanie kontrolera gier, aby utworzyć obiekty

jeden. Utwórz klasę kontrolera gier. Sterowniki gier są odpowiedzialne za kurs gry. Nie pokrywają się z klasą samej gry, która jest odpowiedzialna za rysowanie i aktualizację wszystkich obiektów gry. Kontroler będzie okresowo dodać nową piłkę na ekranie i komplikuje grę. Dodaj projektant i zainicjuj kilka wartości początkowych. Interwał będzie miała czas, przez który zostanie dodana nowa piłka.

Klasa Gamecontroller: Def __init __ (ja, interwał = 5):.Inter = interalistyczny.Następny = Pygame.Czas.Get_ticks () + (2 * 1000).Typ = "Kontroler gry"

2. Dodaj funkcję aktualizacji. Sprawdzi, ile czasu minęło, ponieważ dodanie poprzedniej piłki lub od początku gry. Jeśli czas przekroczy określony interwał, zresetowano timer, a nowa piłka została dodana.

Klasa Gamecontroller:...Aktualizacja Def (Self, GameObjects): Jeśli siebie.Kolejny < pygame.time.get_ticks():self.next = pygame.time.get_ticks() + (self.inter * 1000)gameObjects.append(Ball())

3. Zainstaluj losowe prędkości dla piłek. Aby grać zachowała się inaczej, konieczne jest zezwolenie na użycie liczb losowych do parametru prędkości. Teraz prędkość piłek zostanie określona przez zmienną liczbę dziesiętną, a nie całkowitą.

Klasa Gamecontroller:...Aktualizacja Def (Self, GameObjects): Jeśli siebie.Kolejny < pygame.time.get_ticks():self.next = pygame.time.get_ticks() + (self.inter * 1000)gameObjects.append(Ball(xVel=random()*2, yVel=random()*2))

cztery. Popraw cechę rysunku. Funkcja rysowania nie działa z pływającymi półkolonami (pływak). Dlatego konieczne jest wyrażenie pozycji piłki na liczbach całkowitych przed ich przyciągnięciem.

Klasa Piłka:...Def Draw (Self, Powierzchnia): Pygame.Remis.Koło (powierzchnia, czarna, (int (ja.x), int (ja.y)), jaźń.PROMIEŃ)

pięć. Określ metodę rysowania kontrolera gry. Ponieważ jest to również obiekt gry, w głównym cyklu gry będzie próbę przyciągnięcia go. Dlatego dla kontrolera konieczne jest określenie funkcji rysunku, co nie robi nic, aby uniknąć awarii gry.

Klasa Gamecontroller:...Def Draw (Self, Ekran): Pass

6. Dodaj kontroler gry w Gamebjects i Usuń 2 kulki. Gra musi dodać nową piłkę co 5 sekund.

Gra klasy (): Def __init __ (Self):...Samego siebie.Gamebjects = [].Gamebjects.Appendroller (Gamecontroller ()).Gamebjects.Append (gracz ())

Obraz zatytułowany programisGamepart6.jpg

7. Wypróbuj program! Teraz kod programu powinien wyglądać tak:

Importuj Pygampefrom Losowy import RandomFrom Pygame.Liczba Importuj * Rozdzielczość = (400,300) White = (255,255255) Black = (0.0.0) Red = (255,0,0) Ekran = Pygame.Pokaz.Set_mode (rozdzielczość) Klasa: Def __init __ (Self, XPO = Rozdzielczość [0] / 2, YPO = Rozdzielczość [1] / 2, Xvel = 1, Yvel = 1, Rad = 15):.x = xposself.Y = yposself.Dx = xveelfelf.Dy = Yvielnia.Radius = Redself.Typ = "Piłka"Def Draw (Self, Powierzchnia): Pygame.Remis.Koło (powierzchnia, czarna, (int (ja.x), int (ja.y)), jaźń.RADIUS) Aktualizacja Def (Self, Gamebjects): Self.X + = jaźń.Dself.Y + = self.Dif (jaźń.X <= 0 or self.x >= Rozdzielczość [0]): Jaźń.Dx * = -1if (ja.y <= 0 or self.y >= Rozdzielczość [1]): Self.DY * = -1Class Player: Def __init __ (Self, Rad = 20): Self.x = sam.Y = 0.Radius = Redself.Typ = "Gracz"Def Draw (Self, Powierzchnia): Pygame.Remis.Koło (powierzchnia, czerwony (ja.X, jaźń.y), ja.RADIUS) Def Update (Self, GameObjects): Cord = Pygame.Mysz.Get_pos () Self.X = sznur [0].Y = sznur [1] dla GameObj w Gamebjects: jeśli GAMEOBJ.Typ == "Piłka": If (Gameobj.X - jaźń.x) ** 2 + (Gameobj.Y - ja.y) ** 2 <= (gameObj.radius + self.radius)**2:pygame.quit()class GameController:def __init__(self, interval = 5):self.inter = intervalself.next = pygame.time.get_ticks() + (2 * 1000)self.type = "game controller"def update(self, gameObjects):if self.next < pygame.time.get_ticks():self.next = pygame.time.get_ticks() + (self.inter * 1000)gameObjects.append(Ball(xVel=random()*2, yVel=random()*2))def draw(self, screen):passclass game():def __init__(self):pygame.init()self.screen = pygame.display.set_mode(resolution)self.clock = pygame.time.Clock()self.gameObjects = []self.gameObjects.append(GameController())self.gameObjects.append(Player())def handleEvents(self):for event in pygame.event.get():if event.type == QUIT:pygame.quit()def run(self):while True:self.handleEvents()for gameObj in self.gameObjects:gameObj.update(self.gameObjects)self.screen.fill(white)for gameObj in self.gameObjects:gameObj.draw(self.screen)self.clock.tick(60)pygame.display.flip()game().run()

Część 8 z 8:

Dodawanie konta i zakończenia gry

jeden. Dodaj konto do klasy kontrolera Gaming. Utwórz obiekt klasy czcionki i zmienną wynikową. Obiekt czcionki należy przyciągnąć w każdej klatce, aby wyświetlić konto bieżące i zwiększa ją w każdej klatce podczas aktualizacji.

Klasa Gamecontroller: Def __init __ (ja, interwał = 5):...Samego siebie.Wynik = sam.ScoreText = Pygame.czcionka.Czcionka (brak, 12) Aktualizacja Def (Self, GameObjects):...Samego siebie.Wynik + = 1DEF Draw (Self, Ekran): Ekran.Blit (jaźń.ScoreText.Renderowany (ul.Wynik), prawdziwy, czarny), (5,5))

2. Zmień proces wypełniania gry. Usuń prosty sposób z gry, gdy kolizja gracza z piłką. Zamiast tego utwórz zmienną w klasie gracza, który zostanie sprawdzony grając. Kiedy zmienna Gameover staje się prawdziwa, musisz zatrzymać aktualizację obiektów. Wszystkie obiekty są zamrożone na miejscu, więc gracz będzie w stanie zrozumieć, co się stało i zobaczy jego konto. Obiekty będą nadal wyświetlane na ekranie, ale po prostu zatrzymają się zaktualizowane.

Gracz klasy: Def __init __ (Self, Rad = 20):...Samego siebie.Gameover = Falsedef Update (Self, Gamebjects):...W GAMEOBJ W GAMEOBICTS: IF GAMEOBJ.Typ == "Piłka": If (Gameobj.X - jaźń.x) ** 2 + (Gameobj.Y - ja.y) ** 2 <= (gameObj.radius + self.radius)**2:self.gameOver = Trueclass game():def __init__(self):...self.gameOver = Falsedef run(self):while True:self.handleEvents()if not self.gameOver:for gameObj in self.gameObjects:gameObj.update(self.gameObjects)if gameObj.type == "player":self.gameOver = gameObj.gameOver

Obraz zatytułowany program temapygaminfinal.jpg

3. Wypróbuj program! Ostateczny kod programu powinien wyglądać tak:

Importuj Pygampefrom Losowy import RandomFrom Pygame.Liczba Importuj * Rozdzielczość = (400,300) White = (255,255255) Black = (0.0.0) Red = (255,0,0) Ekran = Pygame.Pokaz.Set_mode (rozdzielczość) Klasa: Def __init __ (Self, XPO = Rozdzielczość [0] / 2, YPO = Rozdzielczość [1] / 2, Xvel = 1, Yvel = 1, Rad = 15):.x = xposself.Y = yposself.Dx = xveelfelf.Dy = Yvielnia.Radius = Redself.Typ = "Piłka"Def Draw (Self, Powierzchnia): Pygame.Remis.Koło (powierzchnia, czarna, (int (ja.x), int (ja.y)), jaźń.RADIUS) Aktualizacja Def (Self, Gamebjects): Self.X + = jaźń.Dself.Y + = self.Dif (jaźń.X <= 0 or self.x >= Rozdzielczość [0]): Jaźń.Dx * = -1if (ja.y <= 0 or self.y >= Rozdzielczość [1]): Self.DY * = -1Class Player: Def __init __ (Self, Rad = 20): Self.x = sam.Y = 0.Radius = Redself.Typ = "Gracz"Samego siebie.Gameover = Falsedef Draw (Self, Powierzchnia): Pygame.Remis.Koło (powierzchnia, czerwony (ja.X, jaźń.y), ja.RADIUS) Def Update (Self, GameObjects): Cord = Pygame.Mysz.Get_pos () Self.X = sznur [0].Y = sznur [1] dla GameObj w Gamebjects: jeśli GAMEOBJ.Typ == "Piłka": If (Gameobj.X - jaźń.x) ** 2 + (Gameobj.Y - ja.y) ** 2 <= (gameObj.radius + self.radius)**2:self.gameOver = Trueclass GameController:def __init__(self, interval = 5):self.inter = intervalself.next = pygame.time.get_ticks() + (2 * 1000)self.type = "game controller"self.score = 0self.scoreText = pygame.font.Font(None, 12)def update(self, gameObjects):if self.next < pygame.time.get_ticks():self.next = pygame.time.get_ticks() + (self.inter * 1000)gameObjects.append(Ball(xVel=random()*2, yVel=random()*2))self.score += 1def draw(self, screen):screen.blit(self.scoreText.render(str(self.score), True, black), (5,5))class game():def __init__(self):pygame.init()self.screen = pygame.display.set_mode(resolution)self.clock = pygame.time.Clock()self.gameObjects = []self.gameObjects.append(GameController())self.gameObjects.append(Player())self.gameOver = Falsedef handleEvents(self):for event in pygame.event.get():if event.type == QUIT:pygame.quit()def run(self):while True:self.handleEvents()if not self.gameOver:for gameObj in self.gameObjects:gameObj.update(self.gameObjects)if gameObj.type == "player":self.gameOver = gameObj.gameOverself.screen.fill(white)for gameObj in self.gameObjects:gameObj.draw(self.screen)self.clock.tick(60)pygame.display.flip()game().run()