- 19 września 2026
- Posted by: Damian
- Category: Python

Tworzenie gier to fascynująca oraz ciekawa dziedzina. Jednak istotne jest to, że możesz połączyć przyjemne z pożytecznym. Nie tylko stworzysz coś co Cię fascynuje, ale jednocześnie nauczysz się wielu nowych rzeczy, jeśli chodzi o programowanie. W ramach tej dziedziny stworzono różnorodne biblioteki, dzięki którym uda Ci się stworzyć własną grę. Należy jednak zapoznać się z kilkoma pojęciami, które okazują się kluczowe jeśli chodzi o pisanie kodu gier przy użyciu pygame oraz jakiejkolwiek innej biblioteki.
Istotne pojęcia dotyczące gier które warto poznać
Każda z gier posiada punkty wspólne o których warto wiedzieć. Poniższe pojęcia są niezbędne, a przy tym ich znajomość umożliwi Ci znacznie szybsze zrozumienie artykułów na temat tworzenia gier, niezależnie od tego jaki język jest tam używany.
- Silnik gry – jest to tak naprawdę główny kod, który odpowiada za działanie całej gry. Często wspiera on obsługę różnych zdarzeń jak choćby korzystanie z klawiatury czy myszki. Do tego zazwyczaj zapewnia wyświetlanie grafiki, obsługę dźwięku oraz inne kwestie, które są kluczowe w przypadku gier. Silnik gry może zostać stworzony już wcześniej, a w ramach danej gry jedynie dopisuje się odpowiedni kod, który będzie odpowiadał za poszczególne rzeczy. Jednak tak jak w poniższym artykule można też na własną rękę stworzyć prosty lub bardziej skomplikowany silnik. Duża część popularnych silników posiada swoje edytory graficzne (np Unity), chociaż istnieją silniki których używa się bezpośrednio z powodu kodu.
- FPS – to w prostych słowach ilość klatek na sekundę, czyli to jak wiele odświeżeń obrazu nastąpi w czasie sekundy. Wbrew pozorom konieczne jest odgórne ustalenie maksymalnej ilości klatek, inaczej gra będzie działała zbyt szybko i granie w nią okaże się niemożliwe, bo w zaledwie kilka sekund gra obsłuży kilkaset lub kilka tysięcy klatek (powtórzeń głównej pętli). Z takim kłopotem borykają się klasyczne gry uruchomione na nowoczesnych sprzętach, ze względu na brak odgórnie ustalonej ilości FPS, bo komputery na które były tworzone miały bardzo małą moc obliczeniową. W późniejszym czasie usprawniono je, dodając właśnie skrypt określający maksymalną ilość FPS. Jednak w obecnie stosowanych silnikach gier oddzielnie renderuje się klatki (obraz), a oddzielnie aktualizowana jest np. fizyka. Przykładowo w Unity wartości (choćby dotyczące fizyki) mnożone są przez deltę-t, czyli przez czas, jaki upłynął od pojawienia się ostatniej klatki. Pozwala to na zachowanie płynności działania gry niezależnie od tego jak wiele klatek zostanie wyświetlonych w określonym przedziale czasu. Celowe ograniczenie ilości klatek może służyć zmniejszeniu tzw. “stutter,” czyli wahań w ilości klatek, oraz zmniejszeniu zużycia energii przez komputer, który może chodzić na mniejszych obrotach.
- System kolizji – jest to część kodu odpowiadająca za interakcję między postaciami ( w tym postacią gracza), przedmiotami, ścianami czy innymi obiektami w grze. Dzięki temu zatrzyma się ona w konkretnym miejscu bez możliwości przejścia przez ścianę, czy też w przypadku wroga zada on określone obrażenia gdy gracz natknie się na niego.
- GUI – graficzny interfejs użytkownika. W przypadku gier chodzi o wszelkiego rodzaju obrazy wyświetlane na ekranie, takie jak postać, przeciwnicy, przedmioty, czy także przyciski.
Co to jest pygame?
Pygame to specjalna biblioteka w Pythonie, stworzona przez Pete Shinnersa. Służy ona do tworzenia gier lub aplikacji multimedialnych. Korzysta z SDL do wyświetlania grafiki, odtwarzania audio (dźwięku lub muzyki), obsługi myszy oraz klawiatury, czy obsługi czasu. Ogromną zaletą w przypadku Pygame jest multiplatformowość, bo można korzystać z tej biblioteki na wielu systemach jak choćby Linux, Windows czy Mac. Dodatkowo należy zauważyć, że została rozpowszechniona na zasadach licencji LGPL czyli wolnego oprogramowania. Także teraz już wiesz co to jest pygame.
Pygame – Poradnik
W tym poradniku znajdziesz sposób na stworzenie dwóch gier, czyli Memory oraz Snake’a. Zapewne zasady rozgrywki tych klasycznych tytułów są Ci znane, dzięki czemu ich analiza okaże się jeszcze łatwiejsza.

W ramach tego poradnika korzysta się jedynie z biblioteki pygame oraz random. Python jest wygodnym językiem szczególnie do tworzenia gier 2D. Popularne na całym świecie gry w pythonie to między innymi Civilization IV, Battlefield 2, Mount & Blade, World of Tanks czy The Sims 4, choć należy zaznaczyć, że w wymienionych tytułach python odpowiada za różnego rodzaju skrypty dotyczące zdarzeń lub zachowań. Natomiast silniki korzystają zazwyczaj z szybszych języków, takich jak C++. Python to stosunkowo wolny język, dlatego silniki oparte są o inne języki, szczególnie gdy chodzi o gry 3D gdzie istnieje konieczność wykonywania ogromnej ilości operacji w krótkim czasie. Jednak w przypadku tytułów 2D jak najbardziej można korzystać z wygodnego pythona.
Jak zainstalować pygame?
Z początku konieczna jest instalacja biblioteki Pygame, uda Ci się to zrobić w swoim środowisku programistycznym (IDE) z pomocą polecenia:
1 | pip install pygame |
Pip to instalator, który rekomenduje większość programistów pythona, a przy tym jest domyślnie dołączony do instalatorów. Jeśli jednak posiadasz zbyt nową wersję Pythona, to może wyświetlać się błąd. W takim przypadku zastosuj tę komendę:
1 | pip install pygame --pre |
Pozwoli ona uwzględnić przedpremierowe wersje pygame. Teraz już wiesz jak zainstalować pygame przy pomocy zaledwie jednej komendy.
Wstęp do gry „Memory”
W przypadku tworzenia jakiejkolwiek gry, kluczowe jest z początku ustalenie założeń, według których ma działać aplikacja. W przypadku memory chodzi o:
- Ilość kafelków (kart) jest odgórnie ustalona;
- Kafelki mają stronę ukrytą (identyczny kolor każdej) oraz odkrytą (po dwie pary w danym kolorze);
- Po naciśnięciu na kafelek jest on odkrywany;
- Po odkryciu dwóch identycznych kafelków stają się one statyczne i nie reagują na dalsze kliknięcia;
- Po odkryciu dwóch różnych kafelków są one zakrywane i ponownie można je wybrać;
- Gra kończy się w momencie dopasowania wszystkich kafelków do siebie.
W ramach kodu gry w pythonie, konieczne jest wstawienie skryptu odpowiadającego za dołączenie do aplikacji biblioteki pygame, jej zainicjowanie oraz stworzenie okna:
1 2 3 4 5 6 7 8 9 10 11 | import pygame pygame.init() #stworzenie okna i ustalenie jego wielkości win = pygame.display.set_mode((500, 500)) #wyświetlenie okna gry oraz ustalenie jego nazwy pygame.display.set_caption("Kafelki - Memory") |
Jednak w tym przypadku okno gry pojawia się zaledwie na chwilę i zniknie. Dzieje się tak, bo nie jest podtrzymywane przez pętlę gry. Jednak łatwo temu zaradzimy z pomocą poniższego kodu:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 | import pygame pygame.init() win = pygame.display.set_mode((500, 500)) pygame.display.set_caption("Kafelki - Memory") gra = True #główna pętla gry while gra: #pętla zdarzeń - z jej pomocą możliwa jest obsługa różnych zdarzeń (kliknięcie lub ruch myszką, używanie klawiatury itp.) for event in pygame.event.get(): #wyłączanie okna gry za pomocą przycisku X if event.type == pygame.QUIT: gra = False |
Dodatkowo w momencie gdy zostanie wykryte zdarzenie QUIT, czyli kliknięcie w przycisk X u rogu okna, to zostanie ono wyłączone, dzięki wyjściu z pętli gra. Zmienna event przyjmuje informacje na temat różnorodnych zdarzeń odbieranych przez ekran gry i można je łatwo odczytać poprzez porównanie go z określonym zdarzeniem.
Teraz przeczytasz o komendach, dzięki którym ta prosta gra w pythonie nabierze kolorytu, a następnie zobaczysz jej pełny kod.
Kluczowe okazuje się wykorzystywanie losowości, bo dzięki temu nawet prosta gra w pythonie zapewnia za każdym razem inne wrażenia. Należy w tym przypadku zaimportować bibliotekę random, co zrobisz w poniższy sposób:
1 | import random |
Przydatna jest także komenda odpowiadająca za zmianę kolejności elementów konkretnej listy. W argumencie należy wstawić nazwę listy, bez jej indeksów. Specyficzny przypadek to listy wielowymiarowe, gdzie każdą pod-listę trzeba “wymieszać” oddzielnie. Pod spodem znajdziesz oba typy zastosowań:
1 2 3 4 5 | random.shuffle(przykładowa_lista) random.shuffle(kafelki_kolory[0]) random.shuffle(kafelki_kolory[1]) |
Z jej pomocą łatwa staje się zmiana odgórnie wpisanych kolorów kafelków w memory. Poniższa gra jest prosta bo obsługuje zaledwie 6 kafelków, jednak można ją śmiało rozszerzyć, dzięki zmianie wartości poszczególnych zmiennych.
Istotne w każdej grze są także kolory, które można przedstawić za pomocą zmiennej obsługującej RGB. Zdołasz ją potem bezpośrednio wstawiać jako argument do funkcji z biblioteki Pygame:
1 | KOLOR = (255, 0, 0) |
Do rysowania kształtów wykorzystywana jest funkcja pygame.draw.rect, która w ramach swoich argumentów obsługuje (nazwa-okna, kolor-kształtu, (pozycja-x, pozycja-y, szerokość-kształtu, wysokość-kształtu)). To fundament jeśli chodzi o pygame GUI. Poniżej przedstawiono przykład jej zastosowania:
1 | pygame.draw.rect(win, KOLOR, (pozycja_x[o], pozycja_y[i], szer, wys)) |
Jednak nic nie zostanie wyświetlone w oknie gry, jeśli nie odświeży się jej obrazu. Do tego służy funkcja pygame.display.update(). Nadpisuje ona wcześniej powstały obraz, dlatego w momencie gdy postać się poruszy, powstałby za nią ślad. Jest to zachowanie analogiczne do rysowania markerem na tablicy bez uprzedniego starcia tego, co było na niej wcześniej.. Dlatego stosowana jest w tym przypadku funkcja win.fill(kolor_RGB), w ramach swojego argumentu przyjmuje ona kolor RGB którym ma zostać zapełniony ekran gry. W ten sposób można wyczyścić cały ekran.
1 2 3 | win.fill((0, 0, 0)) pygame.display.update() |
Przydatna okazuje się także możliwość wyświetlania tekstu na ekranie gry. Zdołasz to osiągnąć dzięki poniżej przedstawionym komendom. Funkcja pygame.font.SysFont(„Arial”,24) przyjmuje jako pierwszy argument rodzaj czcionki, natomiast jako drugi jej wielkość.
Następnie konieczne jest także wyrenderowanie danego tekstu, co osiągniesz za pomocą font.render(„Wygrana!”,False,[255,0,0]). W tym przypadku pierwszy argument to tekst, który ma być wyświetlany, drugi to True lub False odpowiadające za wygładzanie krawędzi tekstu, natomiast trzeci określa kolor wyświetlanej czcionki.
Dopiero w ramach nazwa_okna.blit(text,[200,400]) uda Ci się wyświetlić tekst na ekranie. Pierwszy argument to zmienna przechowująca wyrenderowany tekst, a drugi to pozycja x oraz y na ekranie. Pod spodem masz przykład zastosowania tych komend:
1 2 3 4 5 | font = pygame.font.SysFont("Arial", 24) text = font.render("Wygrana!", False, [255, 0, 0]) win.blit(text, [200, 430]) |
Użyteczna okazuje się też tablica asocjacyjna (nazywana także słownikiem), gdzie w konkretnej zmiennej podaje się w ramach wartości najpierw indeks (może to być dowolny łańcuch znaków) oraz wartość po dwukropku. Gdy chce się wywołać konkretne pole tablicy, wystarczy wpisać w nawiasach kwadratowych łatwy do zapamiętania indeks.
1 2 3 | slownik = {“kolejka”: 0, “punkty”: 0} slownik[“kolejka”] += 1 |
Obsługa myszy, która jest kluczowa w ramach gry memory wymaga:
1 2 | if event.type == pygame.MOUSEBUTTONDOWN: x1, y1 = pygame.mouse.get_pos() |
Pierwsza linijka to kod odpowiadający za sprawdzenie czy wciśnięty został klawisz myszki, kluczowy jest tu oczywiście fragment pygame.MOUSEBUTTONDOWN. Z kolei druga linijka przekazuje informacje o pozycji kursora w danym momencie do zmiennych x1 oraz y1 (nazwy są dowolne).

Ciekawy jest również fragment kodu, dzięki któremu zdołasz ustalić czy kliknięto właśnie w kafelek czy też w inne miejsce. Osiągniesz to poprzez:
1 | if x1>pozycja_x_kafelka and x1<(pozycja_x_kafelka+szerokosc) and y1>pozycja_y_kafelka and y1<(pozycja_y_kafelka+wysokosc) |
W ten sposób jedynie sprawdzasz czy pozycja x myszki jest większa od lewej strony kafelka (jego pozycji x) oraz mniejsza od jego prawej strony (pozycja x + jego szerokość). Identycznie w przypadku pozycji y, gdzie sprawdzasz czy jest mniejsza od góry oraz większa od dołu kafelka. To nie taki skomplikowany kod, jednak pozwala łatwo sprawdzić czy nastąpiła kolizja między myszką, a danym obiektem, a podobny kod odpowiada za bardziej skomplikowane sytuacje w grach, na przykład kolizje fizyczne. To szybki sposób na stworzenie różnego rodzaju przycisków, co jest podstawą jeśli chodzi o obsługę pygame GUI.
Pełny kod gry „Memory”
Pod spodem przedstawiono kod gry memory stworzony przy pomocy biblioteki pygame:
Kod – Memory
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 | import pygame import random #inicjowanie pygame pygame.init() #tworzenie okna gry win = pygame.display.set_mode((500, 500)) #wyświetlenie okna gry pygame.display.set_caption("Kafelki - Memory") gra = True #ustalanie kolorów kafelków kafelki_kolory=[[1,2,3],[2,1,3]] #zmiana kolejności kolorów random.shuffle(kafelki_kolory[0]) random.shuffle(kafelki_kolory[1]) #utworzenie zmiennej i wyzerowanie statusu kafelków (wszystkie są zakryte) kafelki_status=[[0,0,0],[0,0,0]] #ustalenie pozycji kafelków w pionie i poziomie pozycja_x=[68.75, 212.5, 356.25] pozycja_y=[100, 300] #zmienna pomocnicza ustalająca pozycję dwóch ostatnio odkrytych kafelków pozycje_kafelkow=[] #zmienne odpowiadające za obecną kolejkę (ile kafelków odkryto) oraz ilość zdobytych punktów slownik = {"kolejka": 0, "punkty": 0} #ustalenie czcionki używanej w wyświetlanym tekście font = pygame.font.SysFont("Arial", 24) #zmienne tworzące wyświetlany tekst (łańcuch znaków, wygładzanie krawędzi, kolor RGB) text = font.render("Wygrana!", False, [255, 0, 0]) text1 = font.render("Kliknij myszka zeby zresetowac gre.", False, [255, 0, 0]) #zmienna odpowiadająca za kolor kafelków KOLOR = (255, 0, 0) #szerokość i wysokość kafelków szer = 75 wys = 100 #główna pętla gry while gra: #pętla zdarzeń - z jej pomocą możliwa jest obsługa różnych zdarzeń (kliknięcie lub ruch myszką, używanie klawiatury itp.) for event in pygame.event.get(): #wyłączanie okna gry za pomocą przycisku X if event.type == pygame.QUIT: gra = False #obsługa kliknięcia myszą if event.type == pygame.MOUSEBUTTONDOWN: #ustalanie pozycji myszy w czasie kliknięcia x1, y1 = pygame.mouse.get_pos() #po kliknięciu myszką gdy uzyska się maksymalną ilość punktów resetowane są wszystkie zmienne, co umożliwia restart gry if slownik["punkty"]==3: random.shuffle(kafelki_kolory[0]) random.shuffle(kafelki_kolory[1]) kafelki_status=[[0,0,0],[0,0,0]] slownik["kolejka"]=0 slownik["punkty"]=0 #to funkcja czyszcząca ekran, a raczej zapełniająca go określonym kolorem, w tym przypadku pozwala usunąć z ekranu wcześniej zapisany tekst win.fill((0, 0, 0)) #jeśli odkryto dwa kafelki to skrypt sprawdza czy są one identyczne (wtedy zmienia ich barwę na czarną), a jeśli nie to zmienia ich kolor na czerwony if slownik["kolejka"]==2: if kafelki_status[pozycje_kafelkow[0]][pozycje_kafelkow[1]]==kafelki_status[pozycje_kafelkow[2]][pozycje_kafelkow[3]]: kafelki_status[pozycje_kafelkow[0]][pozycje_kafelkow[1]]=-1 kafelki_status[pozycje_kafelkow[2]][pozycje_kafelkow[3]]=-1 slownik["punkty"]+=1 else: kafelki_status[pozycje_kafelkow[0]][pozycje_kafelkow[1]]=0 kafelki_status[pozycje_kafelkow[2]][pozycje_kafelkow[3]]=0 slownik["kolejka"]=0 #usunięcie zakresu indeksów z listy z pozycjami del pozycje_kafelkow[0:4] #poniższy skrypt sprawdza czy kliknięto myszką obszar któregoś z kafelków, a jesli tak to zmienia jego kolor oraz zapisuje jego pozycję for i in range(0,2): for o in range(0,3): if x1>pozycja_x[o] and x1<(pozycja_x[o]+szer) and y1>pozycja_y[i] and y1<(pozycja_y[i]+wys) and kafelki_status[i][o]!=-1: kafelki_status[i][o]=kafelki_kolory[i][o] slownik["kolejka"]+=1 pozycje_kafelkow.append(i) pozycje_kafelkow.append(o) #zmiana koloru RGB w zmiennej KOLOR for i in range(0,2): for o in range(0,3): KOLOR = (255, 0, 0) if kafelki_status[i][o]==1: KOLOR = (0,204,204) elif kafelki_status[i][o]==2: KOLOR = (204,0,204) elif kafelki_status[i][o]==3: KOLOR = (255,255,0) elif kafelki_status[i][o]==-1: KOLOR = (0,0,0) #rysowanie prostokątów (kafelków) pygame.draw.rect(win, KOLOR, (pozycja_x[o], pozycja_y[i], szer, wys)) #wyświetlenie tekstu o wygranej oraz resecie gry, jeśli uzyskano maksymalną ilość punktów if slownik["punkty"]==3: win.blit(text, [200, 430]) win.blit(text1, [30, 460]) #odświeżenie ekranu pygame.display.update() |
Wstęp do klasycznej gry „Snake”
Masz już za sobą statyczną grę jaką jest memory. Teraz przyszedł czas na dynamiczną zabawę z pomocą klasycznego snake’a. Warto najpierw określić założenia tej gry:
- Wąż porusza się po kafelkach o ustalonym wcześniej rozmiarze;
- Cała plansza składa się z identycznych kafelków;
- Na planszy w losowym miejscu (dla ułatwienia gry omija się dwa kafelki najbliżej brzegu planszy) pojawia się punkt (owoc) możliwy do zjedzenia przez węża;
- Wąż rośnie o długość jednego kafelka po zjedzeniu punktu;
- Gra kończy się w momencie dotknięcia krańca planszy lub swojego ogona przez węża;
- Ilość punktów jest wyświetlana na ekranie.
Do stworzenia tej gry wykorzystuje się w większości komendy, które udało Ci się poznać wcześniej. Jednak jest tu kilka nowości jeśli chodzi o polecenia pygame oraz ogólne algorytmy.
Przede wszystkim korzysta się w tym przypadku z opcji zegara, który umożliwia ustalenie odgórnej ilości FPS, czyli klatek na sekundę. Jest to możliwe dzięki poniższym komendom:
1 2 3 | clock = pygame.time.Clock() clock.tick(10) |
Pierwsza linijka to stworzenie zegara, który będzie obsługiwał grę. Dopiero z jego pomocą można korzystać z różnych komend, takich jak właśnie tick. W przypadku tego polecenia w argumencie podaje się ile klatek na sekundę może przerobić pętla gry, czyli im większa wartość w argumencie, tym szybciej przebiega gra.
Drugim istotnym rodzajem komend jest tu oczywiście też obsługa klawiszy.
1 2 3 | klawisz = pygame.key.get_pressed() if klawisz[pygame.K_LEFT]: |
Do zmiennej klawisz zapisywane jest obecne użycie klawiatury. Z kolei w kolejnej linijce dzięki wykorzystaniu zmiennej klawisz podobnie do listy i sprawdzeniu indeksu pygame.K_LEFT można się zorientować czy strzałka w lewo została użyta, bo zostanie wtedy zwrócona wartość True. Analogicznie, jeśli nie użyto tego klawisza, to zwróci się wartość False. Inne klawisze ze strzałkami to:
- pygame.K_RIGHT,
- pygame.K_UP,
- pygame.K_DOWN.
Oprócz opisanych powyżej komend najbardziej istotne w przypadku gry snake, jest sprytne użycie listy jako zbioru elementów z których składa się postać. Jednak najpierw objaśnię w skrócie zasadę poruszania się węża.
Polega ona na ustaleniu kierunku w którym ma się poruszać, w tym przypadku uzyskano to za pomocą listy z dwoma elementami, gdzie pierwszy odpowiada za oś x, natomiast drugi za oś y. W momencie gdy wąż ma poruszać się w górę, to drugi element listy zyskuje wartość -1 (bo im wyżej do góry, tym mniejsza wartość y, jako że x oraz y są liczone od lewego górnego rogu ekranu gry). Z kolei jeśli wąż ma zacząć poruszać się w prawo, to pierwszy element listy zyskuje wartość 1, natomiast drugi jest zerowany.
Następnie w grę wchodzi zmiana obecnej pozycji węża i tu właśnie trzeba zorientować się w jaki sposób wykorzystać zasadę działania listy.
W przypadku tej gry zastosowano listę krotek, czyli listę składającą się ze zbioru krotek składających się z dwóch elementów, gdzie jedna odpowiada za oś x, a druga za oś y.
1 | lista_pozycji = [((ilosc_kafelkow // 2) - 1, ilosc_kafelkow // 2), (ilosc_kafelkow // 2, ilosc_kafelkow // 2)] |
Krotki to odpowiednik listy (wartości zapisuje się poprzez nawiasy okrągłe, a nie kwadratowe), jednak istotne jest to, że nie można modyfikować zawartych w nich danych. Dlatego w przypadku zwykłych krotek posiadających nawet wiele elementów, nie można dodać nowych wartości. Jednak jeśli krotki umieszczone zostaną w zwykłej liście, można dodawać do tej listy nowe krotki. Jest to użyteczna konstrukcja, która w przypadku gry snake pozwala nie martwić się o przypadkową zmianę danych dotyczących pozycji postaci. Przykład uproszczonej krotki oraz listy krotek, a także przykładowe sposoby na ich wykorzystanie znajdziesz pod spodem:
1 2 3 4 5 6 7 | krotka = (1,2,3) lista_krotek = [(0,1),(0,2),(0,3)] zmienna = krotka[0] + krotka[2] # w tym przypadku sumuje się ze sobą liczbę 1 oraz 3 lista = lista_krotek[0][0] + lista_krotek[2][1] # dodaje się do siebie wartość 0 oraz 3 |
W momencie gdy wąż rusza się o jeden kafelek w którąś ze stron, to dodawany jest nowy element listy krotek z wartościami z ostatniego elementu powiększonymi o wartość kierunku. Jednocześnie usuwany jest pierwszy element listy. Dzięki temu tworzy się iluzję ruchu, poprzez dodanie nowego elementu oraz usunięcie pierwszego. W ramach kodu wygląda to tak:
1 2 3 4 5 | lista_pozycji = lista_pozycji[1:] #usuwamy pierwszy element ostatnia = (ostatnia[0] + kierunek[0], ostatnia[1] + kierunek[1]) lista_pozycji.append(ostatnia) #dodajemy nowy element na koniec listy |
Komenda append odpowiada za dodanie nowego elementu listy o wartości przekazywanej w ramach argumentu w nawiasach. Z kolei zapis [1: ] zwraca kopię oryginalnej tablicy, jednak bez pierwszego elementu listy.
Część osób zdziwi się widząc w kodzie indeks listy o wartości -1, jednak nie jest to błąd. Jest to sposób, na wyznaczenie ostatniego elementu listy, niezależnie od tego jak wiele wartości ona posiada. Analogicznie, jeśli wstawi się tam -2 to wybrany zostanie przedostatni element danej listy.
Pełny kod gry „Snake”
Teraz posiadasz już wystarczającą wiedzę, żeby nawet samodzielnie stworzyć grę snake, jednak przeanalizuj poniższy kod stworzony na potrzeby tego tutorialu pygame, a także zastosuj go w praktyce. Z pewnością dzięki temu nauczysz się jeszcze więcej.
Kod – Snake
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 | import pygame import random # Inicjalizacja pygame pygame.init() # Utworzenie okna gry wielkosc_okna = 500 win = pygame.display.set_mode((wielkosc_okna, wielkosc_okna)) pygame.display.set_caption("Snake") # Tekst, który będzie wyświetlany font = pygame.font.SysFont("Arial", 24) text = font.render("Przegrales!", False, [255, 0, 0]) text1 = font.render("K - Reset gry. D - Wylaczenie gry.", False, [255, 0, 0]) # Kolor węża i punktu KOLOR = (255, 0, 0) # Rozmiar kafelków wielkosc = 10 ilosc_kafelkow = wielkosc_okna // wielkosc # Inicjalizacja pozycji węża i kierunku lista_pozycji = [((ilosc_kafelkow // 2) - 1, ilosc_kafelkow // 2), (ilosc_kafelkow // 2, ilosc_kafelkow // 2)] # Inicjalizacja stanu punktu i pozycji status_punkt = True punkt = 0 pozycja_punkt = [random.randint(2, (ilosc_kafelkow - 2)), random.randint(2, (ilosc_kafelkow - 2))] kierunek = [0, 1] ekran_koncowy = False # Inicjalizacja zegara dla kontroli FPS clock = pygame.time.Clock() while True: while not ekran_koncowy: win.fill((0, 0, 0)) # Wyświetlanie punktów ilosc_punktow = font.render("Punkty: " + str(punkt), False, [255, 0, 0]) win.blit(ilosc_punktow, [(wielkosc_okna / 2) - 60, 25]) # Pętla zdarzeń for event in pygame.event.get(): if event.type == pygame.QUIT: ekran_koncowy = True # Tworzenie nowego punktu, jeśli stary został zjedzony if not status_punkt: punkt += 1 pozycja_punkt = [random.randint(2, (ilosc_kafelkow - 2)), random.randint(2, (ilosc_kafelkow - 2))] status_punkt = True pygame.draw.rect(win, KOLOR, (wielkosc * pozycja_punkt[0], wielkosc * pozycja_punkt[1], wielkosc, wielkosc)) # Sprawdzanie, czy wąż jest w granicach if 0 <= lista_pozycji[-1][0] < ilosc_kafelkow and 0 <= lista_pozycji[-1][1] < ilosc_kafelkow: for segment in lista_pozycji: pygame.draw.rect(win, KOLOR, (wielkosc * segment[0], wielkosc * segment[1], wielkosc, wielkosc)) else: ekran_koncowy = True # Sprawdzanie naciśnięć klawiszy i zmiana kierunku (zabezpieczenie przed obracaniem o 180 stopni) klawisz = pygame.key.get_pressed() if klawisz[pygame.K_LEFT] and kierunek != [1, 0]: kierunek = [-1, 0] elif klawisz[pygame.K_RIGHT] and kierunek != [-1, 0]: kierunek = [1, 0] elif klawisz[pygame.K_UP] and kierunek != [0, 1]: kierunek = [0, -1] elif klawisz[pygame.K_DOWN] and kierunek != [0, -1]: kierunek = [0, 1] # Aktualizacja pozycji węża ostatnia = lista_pozycji[-1] ostatnia = (ostatnia[0] + kierunek[0], ostatnia[1] + kierunek[1]) lista_pozycji.append(ostatnia) # Usuwanie ogona węża if len(lista_pozycji) > punkt + 2: lista_pozycji = lista_pozycji[1:] # Sprawdzanie, czy wąż zjada punkt if ostatnia[0] == pozycja_punkt[0] and ostatnia[1] == pozycja_punkt[1]: status_punkt = False ostatnia = (ostatnia[0] + kierunek[0], ostatnia[1] + kierunek[1]) lista_pozycji.append(ostatnia) # Sprawdzanie kolizji z samym sobą for i, o in enumerate(lista_pozycji[:-1]): if o == lista_pozycji[-1]: ekran_koncowy = True break pygame.display.update() clock.tick(10) # Ekran końcowy win.blit(text1, [50, wielkosc_okna // 2]) win.blit(text, [50, wielkosc_okna // 3]) pygame.display.update() # Obsługa naciśnięć klawiszy do resetu gry lub wyjścia for event in pygame.event.get(): if event.type == pygame.QUIT: pygame.quit() exit() klawisz = pygame.key.get_pressed() if klawisz[pygame.K_k]: # Reset gry ekran_koncowy = False status_punkt = True punkt = 0 lista_pozycji = [((ilosc_kafelkow // 2) - 1, ilosc_kafelkow // 2), (ilosc_kafelkow // 2, ilosc_kafelkow // 2)] kierunek = [0, 1] elif klawisz[pygame.K_d]: # Wyjście z gry pygame.quit() exit() |
Wbrew pozorom kody dotyczące snake’a oraz memory są naprawdę proste, zwłaszcza w porównaniu z rozbudowanymi grami. Jak widzisz możesz śmiało samodzielnie zacząć tworzyć grę jaką sobie wymarzysz. Wykorzystaj ten pygame tutorial i stwórz własne gry, które pozwolą Ci na jeszcze większy rozwój.
Zadania dodatkowe
- Dodaj większą ilość kafelków do gry memory.
- Wstaw do memory oraz snake’a proste klawisze (do klikania myszką) „start”, „reset”, „wyjdź z gry”.
- Wstaw obrazki do odkrytych i zakrytych kafelków w grze memory.
- Wstaw obraz tła, punktu oraz postaci węża do gry snake.
Spis komend
Pod spodem został umieszczony spis komend objaśnionych wcześniej w ramach tego poradnika pygame, a także kilka dodatkowych, które z pewnością okażą się przydatne:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 | pygame.draw.rect(zmienna_okna, kolor, (pozycja_x, pozycja_y, szerokosc, wysokosc)) – rysowanie kształtu pygame.draw.circle(zmienna_okna, kolor, (pozycja_x, pozycja_y), srednica, wypelnienie) – rysowanie koła pygame.draw.line(zmienna_okna, kolor, (pozycja_x_poczatkowa, pozycja_y_poczatkowa), (pozycja_x_koncowa, pozycja_y_koncowa), grubość_linii) – rysowanie linii bohater=pygame.image.load('obraz.png') – wczytanie obrazu win.blit(bohater, (pozycja_x,pozycja_y)) – wyświetlenie obrazu na ekranie pygame.font.SysFont(‘nazwa_czcionki’, wielkość_czcionki) – wczytanie czcionki font.render(‘tekst’, wygładzanie_krawedzi_True_lub_False, kolor_RGB) – renderowanie tekstu win.blit(zmienna_tekstu, (pozycja_x, pozycja_y)) – wyświetlenie tekstu pygame.key.get_pressed() – pobranie stanu wszystkich przycisków z klawiatury |
Lista klawiszy:
1 2 3 4 5 6 7 8 9 | pygame.K_RIGHT – strzałka w prawo pygame.K_LEFT – strzałka w lewo pygame.K_UP – strzałka w górę pygame.K_DOWN– strzałka w dół pygame.K_d – wciśnięcie klawisza d, analogicznie jeśli chcesz inne znaki, wystarczy, że zamienisz d na przykład na k itd. |
Wczytywanie stanu klawiszy:
1 2 3 | klawisz = pygame.key.get_pressed() if klawisz[pygame.K_LEFT]: |
Wczytywanie stanu myszki i opcje okna:
1 2 3 4 5 6 7 8 9 10 11 | if event.type == pygame.MOUSEBUTTONDOWN: x1, y1 = pygame.mouse.get_pos() zmienna_okna.fill(kolor_RGB) – zamalowanie okna na konkretny kolor pygame.display.update() – odświeżenie zawartości okna clock = pygame.time.Clock() – stworzenie zegara clock.tick(ilość_FPS) – ustalenie ilości FPS gry |


