Szukaj…


Uwagi

Pygame to opakowanie Pythona dla SDL - wieloplatformowej biblioteki C do sterowania multimediami - napisanej przez Pete'a Shinnersa. Oznacza to, że używając pygame możesz pisać gry wideo lub inne aplikacje multimedialne w Pythonie, które będą działały bez zmian na dowolnej platformie obsługiwanej przez SDL (Windows, Unix, Mac, beOS i inne).


W tej sekcji omówiono, czym jest pygame i dlaczego deweloper może chcieć z niej skorzystać.

Powinien także wymieniać wszelkie duże tematy w grze i zawierać linki do powiązanych tematów. Ponieważ Dokumentacja dla gry pygame jest nowa, może być konieczne utworzenie początkowych wersji tych pokrewnych tematów.

Wersje

Wersja | ==============> | Data wydania |
| Pygame 1.9.0 | ========> | 1 sierpnia 2009 r. |
| Pygame 1.8.1 | ========> | 30 lipca 2008 r. |
| Pygame 1.8.0 | ========> | 29 marca 2008 |
| Pygame 1.7.1 | ========> | 16 sierpnia 2005 r. |
| Pygame 1.6.2 | ========> | - |
| Pygame 1.6 | =========> | 23 października 2003 |
| Pygame 1.5 | =========> | 30 maja 2002 r. |
| Pygame 1.4 | =========> | 30 stycznia 2002 |
| Pygame 1.3 | =========> | 19 grudnia 2001 |
| Pygame 1.2 | =========> | 4 września 2001 |
| Pygame 1.1 | =========> | 23 czerwca 2001 |
| Pygame 1.0 | =========> | 5 kwietnia 2001 |
| Pygame 0.9 | =========> | 13 lutego 2001 |
| Pygame 0,5 | =========> | 6 stycznia 14 2001 |
| Pygame 0.4 | =========> | 14 grudnia 2000 |
| Pygame 0.3 | =========> | 20 listopada 2000 |
| Pygame 0.2 | =========> | 3 listopada 2000 |
| Pygame 0.1 | =========> | 28 października 2000 |

Prosta „gra”


Zaimportuj i zainicjuj

Każdy moduł musi zostać zaimportowany, a pygame nie jest wyjątkiem. Chociaż musimy wywołać funkcję pygame.init() aby wszystkie zaimportowane moduły w pygame zostały poprawnie zainicjowane. Jeśli zapomnimy o tym, niektóre moduły nie będą działać. Funkcja zwraca także krotkę wszystkich udanych i nieudanych inicjalizacji (nie zgłosi błędu, jeśli moduł nie zainicjuje).

import pygame
successes, failures = pygame.init()
print("{0} successes and {1} failures".format(successes, failures))

Twórz potrzeby

Musimy także stworzyć wyświetlacz. Pygame już utworzył (ukryty) wyświetlacz, więc wszystko, co musimy zrobić, to ustawić tryb wyświetlania (w tym przykładzie ustawiliśmy tylko rozdzielczość). Dobrym pomysłem jest również utworzenie zegara, aby upewnić się, że nasz program aktualizuje się ze stałą prędkością (w przeciwnym razie działałby z inną prędkością w zależności od tego, jak szybki jest komputer).

screen = pygame.display.set_mode((720, 480))  # Notice the tuple! It's not 2 arguments.
clock = pygame.time.Clock()
FPS = 60  # This variable will define how many frames we update per second.

Dla pewnej czytelności w dalszej części naszego kodu stworzymy dwie stałe kolorów, które reprezentują krotkę czerwonego, zielonego i niebieskiego (RGB). Wartości wynoszą od 0 (brak światła) do 255 (pełne światło).

BLACK = (0, 0, 0)
WHITE = (255, 255, 255)

W pygame zwykle użyć Surface reprezentuje pojawianie się obiektu i rect (prostokąt) reprezentuje położenie obiektu. Powierzchnia jest jak pusty arkusz papieru, który zawiera kolory lub obrazy. Jeśli tworzysz klasę, powinieneś nazwać atrybuty image i rect, ponieważ wiele funkcji będzie szukało tych atrybutów i ich używało. Takie klasy skorzystałyby na odziedziczeniu klasy pygame.sprite.Sprite z powodów, które możesz przeczytać tutaj .

rect = pygame.Rect((0, 0), (32, 32))  # First tuple is position, second is size.
image = pygame.Surface((32, 32))  # The tuple represent size.
image.fill(WHITE)  # We fill our surface with a nice white color (by default black).

Pętla gry

Teraz mamy wszystko ustawione dla naszej pętli gry. Jest to pętla, która będzie działać przez całą grę, w której obsługujemy zdarzenia oraz aktualizujemy ekran i pozycje naszych obiektów.

Najpierw upewnimy się, że nasza pętla wykonuje się przy danym FPS . Zdefiniowaliśmy FPS i stworzyliśmy nasz zegar na początku programu. Poniższy kod upewni nas, że nasz program śpi wystarczająco długo, aby nasza pętla powtórzyła ilość zdefiniowaną przez nas FPS . W tym przykładzie 60 razy na sekundę.

clock.tick(FPS)

Następnie zajmiemy się wydarzeniami. Zdarzenie to w zasadzie działanie użytkownika, takie jak poruszenie myszą lub naciśnięcie klawisza. Pygame zarejestruje wszystkie te zdarzenia w kolejce, którą otrzymamy przez wywołanie pygame.event.get() . Możemy iterować i sprawdzać, czy istnieje zdarzenie, którym chcielibyśmy się zająć. Zdarzenia mają atrybut typu, który możemy sprawdzić względem stałych w module gry, aby określić, jaki to jest typ zdarzenia.

for event in pygame.event.get():
    if event.type == pygame.QUIT:  # The user pressed the close button in the top corner of the window.
        quit()
        # Close the program. Other methods like 'raise SystemExit' or 'sys.exit()'.
        # Calling 'pygame.quit()' won't close the program! It will just uninitialize the modules.

Możemy również sprawdzić, if event.type == pygame.KEYDOWN aby sprawdzić, czy użytkownik nacisnął klawisz. W takim przypadku zdarzenie ma klucz atrybutu , który możemy sprawdzić, aby zobaczyć, który klucz reprezentuje.

for event in pygame.event.get():
    if event.type == pygame.QUIT:
        quit()
    elif event.type == pygame.KEYDOWN:
        if event.key == pygame.K_w:
            rect.move_ip(0, -2)  # Changes the rect's position.
        elif event.key == pygame.K_s:
            rect.move_ip(0, 2)
        elif event.key == pygame.K_a:
            rect.move_ip(-2, 0)
        elif event.key == pygame.K_d:
            rect.move_ip(2, 0)

Teraz musimy wyświetlić nasz obraz. Najpierw możemy wyczyścić ekran z poprzedniego renderowania. Robimy to, wypełniając cały ekran czarnym kolorem (usuń kod, aby zobaczyć, dlaczego chcemy go wyczyścić). Następnie musimy przesłonić nasz obraz do ekranu. Blitting zasadniczo oznacza skopiowanie obrazu na inną powierzchnię (w naszym przypadku na ekran). Na koniec przerzucamy lub aktualizujemy ekran.

Kiedy robimy blitty, tak naprawdę nie wyświetlamy niczego użytkownikowi. Wyobraź sobie, że jest to komputer z jednej strony, a użytkownik z drugiej. Komputer rysuje ( blity ) na boku ekranu, odwraca go w kierunku użytkownika, a następnie powtarza.

screen.fill(BLACK)
screen.blit(image, rect)
pygame.display.update()  # Or 'pygame.display.flip()'.

Teraz mamy podstawową grę! Dość nudne, tak, ale najważniejsze są! W połączeniu z obecną wiedzą na temat języka Python, powinieneś być w stanie stworzyć coś niesamowitego.


Pełny kod

import pygame
successes, failures = pygame.init()
print("{0} successes and {1} failures".format(successes, failures))


screen = pygame.display.set_mode((720, 480))
clock = pygame.time.Clock()
FPS = 60  # Frames per second.

BLACK = (0, 0, 0)
WHITE = (255, 255, 255)
# RED = (255, 0, 0), GREEN = (0, 255, 0), BLUE = (0, 0, 255).

rect = pygame.Rect((0, 0), (32, 32))
image = pygame.Surface((32, 32))
image .fill(WHITE)  

while True:
    clock.tick(FPS)

    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            quit()
        elif event.type == pygame.KEYDOWN:
            if event.key == pygame.K_w:
                rect.move_ip(0, -2)
            elif event.key == pygame.K_s:
                rect.move_ip(0, 2)
            elif event.key == pygame.K_a:
                rect.move_ip(-2, 0)
            elif event.key == pygame.K_d:
                rect.move_ip(2, 0)

    screen.fill(BLACK)
    screen.blit(image, rect)
    pygame.display.update()  # Or pygame.display.flip()

Nieznacznie poprawiona mechanika gry

Pamiętaj, że program sprawdza, kiedy naciskamy klawisz, a nie kiedy przytrzymujemy klawisz. Aby to naprawić, możemy wprowadzić zmienną prędkości . Możemy stworzyć klasę gracza, aby była bardziej zorganizowana. Aby uniknąć ruchu zależnego od ramki (gdybyśmy zmienili liczbę klatek na sekundę na 30, obiekty poruszałyby się z połową prędkości) wprowadzamy ruch zależny od czasu, przekazując czas między tikami do naszych ruchomych obiektów.

import pygame

successes, failures = pygame.init()
print("Initializing pygame: {0} successes and {1} failures.".format(successes, failures))

screen = pygame.display.set_mode((720, 480))
clock = pygame.time.Clock()
FPS = 60

BLACK = (0, 0, 0)
WHITE = (255, 255, 255)


class Player(pygame.sprite.Sprite):
    def __init__(self):
        super().__init__()
        self.image = pygame.Surface((32, 32))
        self.image.fill(WHITE)
        self.rect = self.image.get_rect()  # Get rect of some size as 'image'.
        self.velocity = [0, 0]

    def update(self):
        self.rect.move_ip(*self.velocity)


player = Player()
running = True
while running:
    dt = clock.tick(FPS) / 1000  # Returns milliseconds between each call to 'tick'. The convert time to seconds.
    screen.fill(BLACK)  # Fill the screen with background color.

    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False
        elif event.type == pygame.KEYDOWN:
            if event.key == pygame.K_w:
                player.velocity[1] = -200 * dt  # 200 pixels per second
            elif event.key == pygame.K_s:
                player.velocity[1] = 200 * dt
            elif event.key == pygame.K_a:
                player.velocity[0] = -200 * dt
            elif event.key == pygame.K_d:
                player.velocity[0] = 200 * dt
        elif event.type == pygame.KEYUP:
            if event.key == pygame.K_w or event.key == pygame.K_s:
                player.velocity[1] = 0
            elif event.key == pygame.K_a or event.key == pygame.K_d:
                player.velocity[0] = 0

    player.update()

    screen.blit(player.image, player.rect)
    pygame.display.update()  # Or pygame.display.flip()

print("Exited the game loop. Game will quit...")
quit()  # Not actually necessary since the script will exit anyway.

Jest jeszcze wiele rzeczy, które należy poprawić w tym kodzie. Poleciłbym przeczytać samouczek gry pygame i tę rozmowę Richarda Jonesa, aby uzyskać więcej informacji.

Instalowanie pygame

W systemie Windows

  1. Przejdź do http://www.lfd.uci.edu/~gohlke/pythonlibs/#pygame - nieoficjalnej strony udostępniającej pliki binarne systemu Windows z pakietami Pythona typu open source do oficjalnej dystrybucji CPython przez Christopha Gohlke .

  2. Pobierz odpowiedni plik pygame .whl zgodnie z zainstalowaną wersją Pythona. (Plik nazywa się tak jak pygame - <pygame version> - <python version> - win32.whl )

  3. Biegać

     pip install your-pygame-package.whl
    

    w twoim terminalu, bashu lub konsoli.
    Uwaga: jeśli w PATH nie znaleziono pip spróbuj uruchomić python -m pip install your-pygame-package.whl

  4. Sprawdź, czy możesz zaimportować grę pygame jako moduł python

    import pygame
    

    Jeśli nie pojawi się błąd, poprawnie zainstalowałeś grę komputerową na swoim komputerze :)

W systemie Linux

  1. Otwórz terminal i biegnij

    sudo apt-get install python-pygame
    

    Uwaga: zainstaluje to pygame dla python2

  2. Spróbuj zaimportować do gry pygame

    import pygame
    

    Jeśli nie pojawi się błąd, poprawnie zainstalowałeś grę w systemie Linux :)

Na macOS

Istnieją dwa sposoby instalacji na komputerze Mac:

Metoda 1

Przejdź do strony pobierania Pygame i pobierz instalator Mac. Uruchom go, a powinien zainstalować Pygame na komputerze Mac.

Metoda 2

Zainstaluj Homebrew :

/usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"

Następnie użyj Homebrew, aby zainstalować Python 2.7.12 i Pygame:

brew install python; brew install homebrew/python/pygame

Teraz uruchom Python w swoim terminalu i spróbuj import pygame . Jeśli nic nie mówi, jest instalowany pomyślnie.

Importowanie gry i rysowanie na wyświetlaczu

Pierwsze kroki

Aby rozpocząć korzystanie z Pygame, musisz wykonać następujące czynności:

import pygame

To otwiera okno o rozmiarze 640,480 i zapisuje je w zmiennej o nazwie screen.

Konfigurowanie nazwy okna

Ustawienie nazwy okna gry wymaga następującej składni:

pygame.display.set_caption('Name')

O ekranie

  • Punkt (0,0) znajduje się w lewym górnym rogu ekranu.
  • współrzędne x rosną od lewej do prawej, współrzędne y rosną od góry do dołu. To jest współrzędne po prawej stronie na płaszczyźnie kartezjańskiej są dodatnie, a lewa strona jest ujemna. Jednak współrzędne po stronie górnej na płaszczyźnie kartezjańskiej są ujemne u góry i dodatnie na dole. ( Uwaga : Uwzględnia się to, jeśli punkty są pobierane z początku).

Aktualizowanie ekranu

Zmiany, które wprowadzasz na ekranie - np. Wypełnianie go kolorem lub rysowanie na nim, nie pojawiają się natychmiast!
Jak to zrobić?
Musisz wywołać tę funkcję:

pygame.display.update()

Zabarwienie

Kolorowanie w pygame działa w trybie RGB.
Kod do kolorowania to:

color_Name = (r,g,b)
  • R oznacza kolor czerwony.
  • G oznacza zielony
  • B oznacza niebieski.
  • Wszystkie trzy powinny być liczbami całkowitymi od 0 do 255, przy czym 255 jest najjaśniejsze, a 0 jest najciemniejsze

Rysunek

  1. Aby narysować linie

    pygame.draw.lines(screen, color, closed, pointlist, thickness)
    
  2. Aby narysować prostokąt

    pygame.draw.rect(screen, color, (x,y,width,height), thickness)
    
  3. Aby narysować okrąg

    pygame.draw.circle(screen, color, (x,y), radius, thickness)
    

Wszystko w pętli

Aby utworzyć pętlę, użyj następującego kodu:

running = True
while running:
  for event in pygame.event.get():
    if event.type == pygame.QUIT:
      running = False
      pygame.quit()

Rysowanie prostokąta w oknie gry (kod)

import pygame
background_colour = (255,255,255) # White color
(width, height) = (300, 200) # Screen size
color=(0,0,0) #For retangle
screen = pygame.display.set_mode((width, height)) #Setting Screen
pygame.display.set_caption('Drawing') #Window Name
screen.fill(background_colour)#Fills white to screen
pygame.draw.rect(screen, color, (100,50,30,40), 1) #Drawing the rectangle
pygame.display.update()

#Loop
running = True
while running:
  for event in pygame.event.get():
    if event.type == pygame.QUIT:
      running = False
      pygame.quit()


Modified text is an extract of the original Stack Overflow Documentation
Licencjonowany na podstawie CC BY-SA 3.0
Nie związany z Stack Overflow