To jest wprowadzenie do Pygame dla osób, które już znają Pythona. Ten artykuł nauczy Cię, jak zbudować prostą grę, w której gracz będzie unikał odbijających się piłek.
Kroki
Część 1 z 8: Instalacja Pygame
Krok 1. Pobierz Pygame
Znajdź go dla swojej platformy na stronie
Krok 2. Uruchom instalator
Krok 3. Sprawdź, czy instalacja zadziałała
Otwórz terminal Pythona. Wpisz „importuj pygame”. Jeśli nie widzisz żadnych błędów, Pygame został pomyślnie zainstalowany.
importuj pygame
Część 2 z 8: Konfigurowanie podstawowego okna
Krok 1. Otwórz nowy plik
Krok 2. Importuj Pygame
Pygame to biblioteka zapewniająca dostęp do funkcji graficznych. Więcej informacji na temat działania tych funkcji można znaleźć na stronie Pygame.
import pygame z pygame.locals import *
Krok 3. Ustaw rozdzielczość okna
Będziesz tworzyć zmienną globalną dla rozdzielczości ekranu, aby można było się do niej odwoływać w kilku częściach gry. Można go również łatwo znaleźć na górze pliku, dzięki czemu można go później zmienić. W przypadku zaawansowanych projektów lepszym pomysłem byłoby umieszczenie tych informacji w osobnym pliku.
rozdzielczość = (400, 300)
Krok 4. Zdefiniuj niektóre kolory
Kolory w pygame to (RBGA, które wahają się w wartościach od 0 do 255. Wartość alfa (A) jest opcjonalna, ale inne kolory (czerwony, niebieski i zielony są obowiązkowe).
biały = (255, 255, 255) czarny = (0, 0, 0) czerwony = (255, 0, 0)
Krok 5. Zainicjuj ekran
Użyj zmiennej rozdzielczości, która została zdefiniowana wcześniej.
ekran = pygame.display.set_mode(rozdzielczość)
Krok 6. Zrób pętlę gry
Powtarzaj określone czynności w każdej klatce naszej gry. Utwórz pętlę, która zawsze będzie się powtarzać, aby przejść przez wszystkie te czynności.
podczas gdy prawda:
Krok 7. Pokoloruj ekran
screen.fill(biały)
Krok 8. Wyświetl ekran
Jeśli uruchomisz program, ekran zmieni kolor na biały, a następnie program się zawiesi. Dzieje się tak, ponieważ system operacyjny wysyła zdarzenia do gry, a gra nic z nimi nie robi. Gdy gra otrzyma zbyt wiele nieobsługiwanych zdarzeń, zawiesi się.
while True: … pygame.display.flip()
Krok 9. Obsługuj zdarzenia
Uzyskaj listę wszystkich zdarzeń, które miały miejsce w każdej klatce. Będziesz się troszczył tylko o jedno wydarzenie, o zakończenie. Dzieje się tak, gdy użytkownik zamyka okno gry. Zapobiegnie to również zawieszaniu się naszego programu z powodu zbyt wielu zdarzeń.
while True: … dla zdarzenia w pygame.event.get(): if event.type == QUIT: pygame.quit()
Krok 10. Wypróbuj
Oto jak powinien teraz wyglądać kod:
importuj pygame z pygame.locals import * rozdzielczość = (400, 300) biały = (255, 255, 255) czarny = (0, 0, 0) czerwony = (255, 0, 0) screen = pygame.display.set_mode(rozdzielczość) while True: screen.fill(white) pygame.display.flip() dla zdarzenia w pygame.event.get(): if event.type == QUIT: pygame.quit()
Część 3 z 8: Tworzenie obiektu gry
Krok 1. Utwórz nową klasę i konstruktora
Ustaw wszystkie właściwości obiektu. Podajesz również wartości domyślne dla wszystkich właściwości.
class Ball: def _init_(self, xPos = rozdzielczość[0] / 2, yPos = rozdzielczość[1] / 2, xVel = 1, yVel = 1, rad = 15): self.x = xPos self.y = yPos self.dx = xVel self.dy = yVel self.radius = rad self.type = "piłka"
Krok 2. Zdefiniuj sposób rysowania obiektu
Użyj właściwości, które zostały zdefiniowane w konstruktorze, aby narysować kulkę jako okrąg, a także przekazać powierzchnię do funkcji, na której narysujesz obiekt. Powierzchnią będzie obiekt ekranowy, który został utworzony wcześniej przy użyciu rozdzielczości.
def draw(self, surface): pygame.draw.circle(surface, black, (self.x, self.y), self.radius)
Krok 3. Stwórz instancję klasy i powiedz pętli gry, aby rysowała piłkę w każdej pętli
ball = Ball() while True: … ball.draw(screen)
Krok 4. Przesuń obiekt
Utwórz funkcję, która zaktualizuje położenie obiektu. Wywołaj tę funkcję w każdej pętli gry.
class Ball: … def update(self): self.x += self.dx self.y += self.dy
Krok 5. Ogranicz liczbę klatek na sekundę
Piłka będzie się poruszać bardzo szybko, ponieważ pętla gry toczy się setki razy na sekundę. Użyj zegara Pygame, aby ograniczyć liczbę klatek na sekundę do 60 fps.
clock = pygame.time. Clock() while True: … clock.tick(60)
Krok 6. Trzymaj piłkę na ekranie
Dodaj kontrole w funkcji aktualizacji, aby odwrócić kierunek piłki, jeśli uderzy ona w jedną z krawędzi ekranu.
class Ball: … def update(self): … if (self.x <= 0 lub self.x >= rozdzielczość[0]): self.dx *= -1 if (self.y <= 0 lub self.y >= rozdzielczość[1]): self.dy *= -1
Krok 7. Wypróbuj
Oto jak powinien teraz wyglądać kod:
importuj pygame z pygame.locals import * rozdzielczość = (400, 300) biały = (255, 255, 255) czarny = (0, 0, 0) czerwony = (255, 0, 0) screen = pygame.display.set_mode(rozdzielczość) class Ball: def _init_(self, xPos = resolution[0] / 2, yPos = resolution[1] / 2, xVel = 1, yVel = 1, rad = 15): self.x = xPos self.y = yPos self.dx = xVel self.dy = yVel self.radius = rad self.type = "piłka" def draw(self, surface): pygame.draw.circle(surface, black, (self.x, self.y), self.radius) def update(self): self.x += self.dx self.y += self.dy if (self.x <= 0 lub self.x >= rozdzielczość[0]): self.dx *= -1 if (self.y <= 0 lub self.y >= rozdzielczość[1]): self.dy *= -1 ball = Ball() clock = pygame.time. Clock() podczas True: screen. fill(biały) ball.draw(screen) ball.update() pygame.display.flip() clock.tick(60) dla zdarzenia w pygame.event.get(): if event.type == QUIT: pygame.quit ()
Część 4 z 8: Organizacja gry
Krok 1. Użyj zajęć, aby wszystko zorganizować
Gra stanie się bardziej skomplikowana. Użyj technik zorientowanych obiektowo, aby uporządkować swój kod.
Krok 2. Zmień pętlę gry w klasę
Ponieważ nasza gra zawiera teraz dane, w tym obiekty i funkcje gry, sensowne jest przekształcenie pętli gry w klasę.
klasa gra():
Krok 3. Dodaj konstruktora
Tutaj stworzysz instancje niektórych obiektów gry, stworzysz nasz ekran i zegar oraz zainicjujesz Pygame. Aby korzystać z niektórych funkcji, takich jak tekst lub dźwięk, należy zainicjować Pygame.
class game(): def _init_(self): pygame.init() self.screen = pygame.display.set_mode(rozdzielczość) self.clock = pygame.time. Clock()
Krok 4. Obsługa zdarzeń w funkcji
class game(): … def handleEvents(self): dla zdarzenia w pygame.event.get(): if event.type == QUIT: pygame.quit()
Krok 5. Ustaw pętlę gry w funkcję
Wywołaj funkcję obsługi zdarzeń w każdej pętli.
class game(): … def run(self): while True: self.handleEvents() self.screen.fill(white) self.clock.tick(60) pygame.display.flip()
Krok 6. Obsługuj wiele obiektów gry
W tej chwili ten kod musi wywoływać draw i aktualizować nasz obiekt w każdej klatce. Byłoby bałagan, gdybyś miał dużo obiektów. Dodajmy nasz obiekt do tablicy, a następnie zaktualizujmy i narysujmy wszystkie obiekty w tablicy w każdej pętli. Teraz możesz łatwo dodać kolejny obiekt i nadać mu inną pozycję początkową.
class game(): def _init_(self): … self.gameObjects = self.gameObjects.append(Ball()) self.gameObjects.append(Ball(100)) … def run(self): while True: self.handleEvents() dla gameObj w self.gameObjects: gameObj.update() self.screen.fill(white) dla gameObj w self.gameObjects: gameObj.draw(self.screen) self.clock.tick(60) pygame.display.trzepnięcie()
Krok 7. Wypróbuj
Oto jak powinien teraz wyglądać kod:
importuj pygame z pygame.locals import * rozdzielczość = (400, 300) biały = (255, 255, 255) czarny = (0, 0, 0) czerwony = (255, 0, 0) screen = pygame.display.set_mode(rozdzielczość) class Ball: def _init_(self, xPos = resolution[0] / 2, yPos = resolution[1] / 2, xVel = 1, yVel = 1, rad = 15): self.x = xPos self.y = yPos self.dx = xVel self.dy = yVel self.radius = rad self.type = "piłka" def draw(self, surface): pygame.draw.circle(surface, black, (self.x, self.y), self.radius) def update(self): self.x += self.dx self.y += self.dy if (self.x <= 0 lub self.x >= rozdzielczość[0]): self.dx *= -1 if (self.y <= 0 lub self.y >= rozdzielczość[1]): self.dy *= -1 class game(): def _init_(self): pygame.init() self.screen = pygame.display.set_mode(rozdzielczość) self.clock = pygame.time. Clock() self.gameObjects = self.gameObjects.append(Ball()) self.gameObjects.append(Ball(100)) def handleEvents(self): dla zdarzenia w pygame.event.get(): if event.type == QUIT: pygame.quit() def run(self): while True: self.handleEvent s() dla gameObj w self.gameObjects: gameObj.update() self.screen.fill(white) dla gameObj w self.gameObjects: gameObj.draw(self.screen) self.clock.tick(60) pygame.display. flip() gra().uruchom()
Część 5 z 8: Dodawanie obiektu gracza
Krok 1. Stwórz klasę gracza i konstruktora
Utworzysz kolejny okrąg kontrolowany przez myszkę. Zainicjuj wartości w konstruktorze. Jedyną ważną wartością jest promień.
class Player: def _init_(self, rad = 20): self.x = 0 self.y = 0 self.radius = rad
Krok 2. Zdefiniuj sposób rysowania obiektu gracza
Będzie to ten sam sposób, w jaki narysowałeś inne obiekty w grze.
class Player: … def draw(self, surface): pygame.draw.circle(surface, red, (self.x, self.y), self.radius)
Krok 3. Dodaj kontrolę myszy dla obiektu gracza
W każdej klatce sprawdź położenie myszy i ustaw położenie obiektów graczy do tego punktu.
class Player: … def update(self): cord = pygame.mouse.get_pos() self.x = cord[0] self.y = cord[1]
Krok 4. Dodaj obiekt gracza do gameObjects
Utwórz nową instancję odtwarzacza i dodaj ją do listy.
class game(): def _init_(self): … self.gameObjects.append(Player())
Krok 5. Wypróbuj
Oto jak powinien teraz wyglądać kod:
importuj pygame z pygame.locals import * rozdzielczość = (400, 300) biały = (255, 255, 255) czarny = (0, 0, 0) czerwony = (255, 0, 0) screen = pygame.display.set_mode(rozdzielczość) class Ball: def _init_(self, xPos = resolution[0] / 2, yPos = resolution[1] / 2, xVel = 1, yVel = 1, rad = 15): self.x = xPos self.y = yPos self.dx = xVel self.dy = yVel self.radius = rad self.type = "piłka" def draw(self, surface): pygame.draw.circle(surface, black, (self.x, self.y), self.radius) def update(self): self.x += self.dx self.y += self.dy if (self.x <= 0 lub self.x >= rozdzielczość[0]): self.dx *= -1 if (self.y <= 0 lub self.y >= rozdzielczość[1]): self.dy *= -1 class Gracz: def _init_(self, rad = 20): self.x = 0 self.y = 0 self.radius = rad self.type = "player" def draw(self, surface): pygame.draw.circle(surface, red, (self.x, self.y), self.radius) def update (self): cord = pygame.mouse.get_pos() self.x = cord[0] self.y = cord[1] class game(): def _init_(self): pygame.init() self.screen = pygame.zestaw.wyświetlaczy_ mode(rozdzielczość) self.clock = pygame.time. Clock() self.gameObjects = self.gameObjects.append(Gracz()) self.gameObjects.append(Piłka()) self.gameObjects.append(Piłka(100))) def handleEvents(self): dla zdarzenia w pygame.event.get(): if event.type == QUIT: pygame.quit() def run(self): while True: self.handleEvents() dla gameObj w self.gameObjects: gameObj.update() self.screen.fill(white) dla gameObj w self.gameObjects: gameObj.draw(self.screen) self.clock.tick(60) pygame.display.flip() game(). biegać()
Część 6 z 8: Wywoływanie interakcji obiektów z graczem
Krok 1. Zmień funkcje aktualizacji
Aby obiekty mogły wchodzić w interakcje, muszą mieć do siebie dostęp. Dodajmy kolejny parametr do aktualizacji, który zostanie przekazany na liście gameObjects. Musisz dodać go zarówno do obiektu gracza, jak i obiektów piłki. Jeśli masz dużo obiektów w grze, dziedziczenie może pomóc w utrzymaniu tych samych sygnatur metod.
class Ball: … def update(self, gameObjects): … class Player: … def update(self, gameObjects):
Krok 2. Sprawdź kolizje między graczem a piłkami
Przejrzyj wszystkie obiekty gry i sprawdź, czy typ obiektu to piłka. Następnie użyj promieni dwóch obiektów i wzoru na odległość, aby sprawdzić, czy się zderzają. Koła są naprawdę łatwe do sprawdzenia kolizji. To największy powód, dla którego nie użyłeś w tej grze innego kształtu.
class Player: … def update(self, gameObjects): … for gameObj in gameObjects: if gameObj.type == "ball": if (gameObj.x - self.x)**2 + (gameObj.y - self.y)**2 <= (obiekt gry.promień + własny.promień)**2:
Krok 3. Zakończ grę, jeśli gracz zostanie trafiony
Na razie zakończmy grę.
if (gameObj.x - self.x)**2 + (gameObj.y - self.y)**2 <= (gameObj.radius + self.radius)**2: pygame.quit()
Krok 4. Wypróbuj
Oto jak powinien teraz wyglądać kod:
importuj pygame z pygame.locals import * rozdzielczość = (400, 300) biały = (255, 255, 255) czarny = (0, 0, 0) czerwony = (255, 0, 0) screen = pygame.display.set_mode(rozdzielczość) class Ball: def _init_(self, xPos = resolution[0] / 2, yPos = resolution[1] / 2, xVel = 1, yVel = 1, rad = 15): self.x = xPos self.y = yPos self.dx = xVel self.dy = yVel self.radius = rad self.type = "piłka" def draw(self, surface): pygame.draw.circle(surface, black, (self.x, self.y), self.radius) def update(self, gameObjects): self.x += self.dx self.y += self.dy if (self.x <= 0 lub self.x >= rozdzielczość[0]): self.dx *= -1 if (self.y <= 0 lub self.y >= rozdzielczość[1]): self.dy *= -1 class Odtwarzacz: def _init_(self, rad = 20): self.x = 0 self.y = 0 self.radius = rad self.type = "player" def draw(self, surface): pygame.draw.circle(surface, red, (self.x, self.y), self.radius) def update(self, gameObjects): cord = pygame.mouse.get_pos() self.x = cord[0] self.y = cord[1] for gameObj in gameObjects: if gameObj.type == "piłka": if (gameObj.x - self.x)**2 + (gameObj.y - self.y)**2 <= (gameObj.radius + self.radius)**2: pygame.quit() class game(): def _init_(self): pygame.init() self.screen = pygame.display.set_mode(rozdzielczość) self.clock = pygame.time. Clock() self.gameObjects = self.gameObjects.append(Player()) self.gameObjects.append(Ball()) self.gameObjects.append(Ball(100)) def handleEvents(self): dla zdarzenia w pygame.event.get(): if event.type == QUIT: pygame.quit () def run(self): while True: self.handleEvents() dla gameObj w self.gameObjects: gameObj.update(self.gameObjects) self.screen.fill(white) dla gameObj w self.gameObjects: gameObj.draw(self.screen) self.clock.tick(60) pygame.display.flip() game().run()
Część 7 z 8: Dodawanie kontrolera gier do tworzenia obiektów
Krok 1. Utwórz klasę kontrolera gier
Kontrolery gier odpowiadają za „uruchomienie” gry. Różni się od naszej klasy gry, która jest odpowiedzialna za rysowanie i aktualizowanie wszystkich naszych obiektów. Kontroler będzie co jakiś czas dodawać kolejną piłkę do ekranu, aby utrudnić grę. Dodaj konstruktora i zainicjuj kilka podstawowych wartości. Interwał będzie to czas przed dodaniem kolejnej piłki.
class GameController: def _init_(self, interval = 5): self.inter = interwał self.next = pygame.time.get_ticks() + (2 * 1000) self.type = "kontroler gry"
Krok 2. Dodaj funkcję aktualizacji
Dzięki temu sprawdzisz, ile czasu minęło od momentu dodania piłki lub od rozpoczęcia gry. Jeśli czas jest dłuższy niż interwał, zresetujesz czas i dodasz piłkę.
class GameController: … def update(self, gameObjects): if self.next < pygame.time.get_ticks(): self.next = pygame.time.get_ticks() + (self.inter * 1000) gameObjects.append(Ball())
Krok 3. Daj kulkom losowe prędkości
Będziesz musiał używać liczb losowych, aby za każdym razem gra była inna. Jednak prędkości kulek są teraz liczbą zmiennoprzecinkową, a nie liczbą całkowitą.
class GameController: … def update(self, gameObjects): if self.next < pygame.time.get_ticks(): self.next = pygame.time.get_ticks() + (self.inter * 1000) gameObjects.append(Ball(xVel=losowy()*2, yVel=losowy()*2))
Krok 4. Napraw funkcję rysowania
Funkcja rysowania nie akceptuje pływaków. Zamieńmy pozycję kuli na liczby całkowite, zanim kulki zostaną wylosowane.
class Ball: … def draw(self, surface): pygame.draw.circle(surface, black, (int(self.x), int(self.y)), self.radius)
Krok 5. Zdefiniuj metodę rysowania dla kontrolera gier
Ponieważ jest to obiekt gry, główna pętla spróbuje go narysować. Będziesz musiał zdefiniować funkcję rysowania, która nic nie robi, aby gra się nie zawieszała.
class GameController: … def draw(self, screen): pass
Krok 6. Dodaj kontroler gier do gameObjects i usuń 2 kulki
Gra powinna teraz odradzać piłkę co pięć sekund.
class game(): def _init_(self): … self.gameObjects = self.gameObjects.append(GameController()) self.gameObjects.append(Player())
Krok 7. Wypróbuj
Oto jak powinien teraz wyglądać kod:
import pygame z random import random z pygame.locals import * rozdzielczość = (400, 300) biały = (255, 255, 255) czarny = (0, 0, 0) czerwony = (255, 0, 0) screen = pygame. display.set_mode(rozdzielczość) class Piłka: def _init_(self, xPos = rozdzielczość[0] / 2, yPos = rozdzielczość[1] / 2, xVel = 1, yVel = 1, rad = 15): self.x = xPos self.y = yPos self.dx = xVel self.dy = yVel self.radius = rad self.type = "piłka" def draw(self, surface): pygame.draw.circle(surface, black, (int(self. x), int(self.y)), self.radius) def update(self, gameObjects): self.x += self.dx self.y += self.dy if (self.x <= 0 lub self. x >= rozdzielczość[0]): self.dx *= -1 if (self.y <= 0 lub self.y >= rozdzielczość[1]): self.dy *= -1 class Player: def _init_(self, rad = 20): self.x = 0 self.y = 0 self.radius = rad self.type = "player" def draw(self, surface): pygame.draw.circle(surface, red, (self.x), self.y), self.radius) def update(self, gameObjects): cord = pygame.mouse.get_pos() self.x = cord[0] self.y = cord[1] dla gameObj w grze Obiekty: if gameObj.type == "ball": if (gameObj.x - self.x)**2 + (gameObj.y - self.y)**2 <= (gameObj.radius + self.radius)* *2: pygame.quit() class GameController: def _init_(self, interval = 5): self.inter = interwał self.next = pygame.time.get_ticks() + (2 * 1000) self.type = "kontroler gier " 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): pass class game(): def _init_(self): pygame.init() self.screen = pygame.display.set_mode(rozdzielczość) self.clock = pygame.time. Clock() self.gameObjects = self.gameObjects.append(GameController()) self.gameObjects.append(Player()) def handleEvents(self): dla zdarzenia w pygame.event.get(): if event.type == QUIT: pygame.quit() def run(self): while True: self.handleEvents() dla gameObj w self.gameObjects: gameObj.update(self.gameObjects) self.screen.fill(biały) dla gameObj w self.gameO obiekty: gameObj.draw(self.screen) self.clock.tick(60) pygame.display.flip() game().run()
Część 8 z 8: Dodawanie wyniku i koniec gry
Krok 1. Dodaj wynik do klasy kontrolera gier
Utwórz obiekt czcionki i zmienną punktacji. Będziesz narysować czcionkę w każdej klatce, aby wyświetlić punktację i zwiększyć punktację w każdej klatce podczas aktualizacji.
class GameController: def _init_(self, interval = 5): … self.score = 0 self.scoreText = pygame.font. Font(Brak, 12) def update(self, gameObjects): … self.score += 1 def draw (self, screen): screen.blit(self.scoreText.render(str(self.score), True, black), (5, 5))
Krok 2. Zmodyfikuj sposób zakończenia gry
Pozbądźmy się wyjścia, gdy gracz wykryje kolizję. Zamiast tego ustawisz zmienną w odtwarzaczu, którą gra może sprawdzić. Gdy gameOver jest ustawione, przestań aktualizować obiekty. To zamrozi wszystko na swoim miejscu, aby gracz mógł zobaczyć, co się stało i sprawdzić swój wynik. Zwróć uwagę, że obiekty są nadal rysowane, ale nie są aktualizowane.
class Player: def _init_(self, rad = 20): … self.gameOver = False def update(self, gameObjects): … for gameObj in gameObjects: if gameObj.type == "ball": if (gameObj.x - self.x)**2 + (gameObj.y - self.y)**2 <= (gameObj.radius + self.radius)**2: self.gameOver = True class game(): def _init_(self): … self.gameOver = False def run(self): while True: self.handleEvents() jeśli nie self.gameOver: for gameObj w self.gameObjects: gameObj.update(self.gameObjects) if gameObj.type == "player": self.gameOver = gameObj.gameOver
Krok 3. Wypróbuj
Oto jak powinien teraz wyglądać gotowy kod:
importuj pygame z losowego importuj losowo z pygame.locals import * rozdzielczość = (400, 300) biały = (255, 255, 255) czarny = (0, 0, 0) czerwony = (255, 0, 0) screen = pygame. display.set_mode(resolution) class Piłka: def _init_(self, xPos = rozdzielczość[0] / 2, yPos = rozdzielczość[1] / 2, xVel = 1, yVel = 1, rad = 15): self.x = xPos self.y = yPos self.dx = xVel self.dy = yVel self.radius = rad self.type = "piłka" def draw(self, surface): pygame.draw.circle(surface, black, (int(self. x), int(self.y)), self.radius) def update(self, gameObjects): self.x += self.dx self.y += self.dy if (self.x <= 0 lub self. x >= rozdzielczość[0]): self.dx *= -1 if (self.y <= 0 lub self.y >= rozdzielczość[1]): self.dy *= -1 class Player: def _init_(self, rad = 20): self.x = 0 self.y = 0 self.radius = rad self.type = "gracz" self.gameOver = False def draw(self, surface): pygame.draw.circle(surface, red, (self.x, self.y), self.radius) def update(self, gameObjects): cord = pygame.mouse.get_pos() self.x = cord[0] self.y = cord[1] dla gameObj w gameObjects: if gameObj.type == "piłka": if (gameObj.x - self.x)**2 + (gameObj.y - self.y)**2 <= (gameObj.radius + self.radius)**2: self.gameOver = True class GameController: def _init_(self, interwał = 5): self.inter = interwał self.next = pygame.time.get_ticks() + (2 * 1000) self. type = "kontroler gry" self.score = 0 self.scoreText = pygame.font. Font(Brak, 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 += 1 def 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(rozdzielczość) self.clock = pygame.time. Clock() self.gameObjects = self.gameObjects.append(GameController()) self.gameObjects.append(Player()) self.gameOver = False def handleEvents(self): dla zdarzenia w pygame.event.get(): if ev ent.type == QUIT: pygame.quit() def run(self): while True: self.handleEvents() jeśli nie self.gameOver: dla gameObj w self.gameObjects: gameObj.update(self.gameObjects) if gameObj. type == "player": self.gameOver = gameObj.gameOver self.screen.fill(white) dla gameObj w self.gameObjects: gameObj.draw(self.screen) self.clock.tick(60) pygame.display.flip () gra().uruchom()
