Twórz własne gry komputerowe w Pythonie

Al Sweigart

Uzyskaj dostęp

Zakup książkę

ISBN/ISSN:

978-83-01-19400-0

DOI:

Wydawnictwo:

Wydawnictwo Naukowe PWN

Rok wydania:

2017

Liczba stron:

418

XML:ISBN/ISSN:

ONIX MARC21

Bibliografia:

Sweigart, Al. Twórz własne gry komputerowe w Pythonie. Red. . Warszawa: Wydawnictwo Naukowe PWN, 2017, 418 s. ISBN 978-83-01-19400-0

Bibliografia refWorks:

RT Book, Whole

SR Electronic(1)

A1 Sweigart, A.

T1 Twórz własne gry komputerowe w Pythonie

PB Wydawnictwo Naukowe PWN

PP Warszawa

YR 2017

SN 978-83-01-19400-0

Bibliografia BibTex:

@Book{ 175799, author = "Sweigart, Al", editor = "", title = "Twórz własne gry komputerowe w Pythonie", publisher = "Wydawnictwo Naukowe PWN", year = "2017", address = "Warszawa", isbn = "978-83-01-19400-0" }

Bibliografia endNote:

TY - BOOK

AU - Sweigart, Al

ED -

TI - Twórz własne gry komputerowe w Pythonie

PB - Wydawnictwo Naukowe PWN

CY - Warszawa

PY - 2017

SN - 978-83-01-19400-0

ER -

Netografia (standard APA):

Sweigart, Al. Twórz własne gry komputerowe w Pythonie [baza danych online] Warszawa: Wydawnictwo Naukowe PWN, 2017 [dostęp: 22 07 2024]. Dostęp w Ibuk Libra: https://libra.ibuk.pl/reader/tworz-wlasne-gry-komputerowe-w-pythonie-al-sweigart-175799.

programowanie, dzieci, gry komputerowe, Python, nauka programowania

Z książki Twórz własne gry komputerowe w Pythonie dowiesz się, jak tworzyć gry komputerowe w tym popularnym języku programowania. Nawet jeżeli jest to twoje pierwsze spotkanie z programowaniem. Zaczniesz od klasycznych gier, takich jak Szubienica,...

Więcej

ISBN/ISSN:

978-83-01-19400-0

DOI:

Wydawnictwo:

Wydawnictwo Naukowe PWN

Rok wydania:

2017

Liczba stron:

418

XML:ISBN/ISSN:

ONIX MARC21

Wstęp do wydania polskiego18
WPROWADZENIE20
Dla kogo przeznaczona jest ta książka?21
Zawartość książki22
Jak korzystać z tej książki23
Długie wiersze kodu24
Numery wierszy i wcięcia24
Pobieranie i instalowanie Pythona25
Uruchamianie IDLE26
Pomoc online27
1 POWŁOKA INTERAKTYWNA30
Kilka prostych działań matematycznych31
Liczby całkowite i rzeczywiste31
Wyznaczanie wartości wyrażeń32
Wyrażenia32
Błędy składniowe34
Zapisywanie wartości w zmiennych34
Podsumowanie38
2 PISANIE PROGRAMÓW40
Wartości łańcuchowe41
Konkatenacja łańcuchów42
Pisanie programów w edytorze plików IDLE42
Tworzenie programu „Hello World”43
Zapisywanie programu44
Wykonywanie programu45
Jak działa program „Hello World”46
Funkcje: miniprogramy w programach46
Komentarze dla programistów46
Nadawanie nazw zmiennym48
Koniec programu48
Podsumowanie49
3 „ZGADNIJ, JAKA TO LICZBA”50
Kod źródłowy gry „Zgadnij, jaka to liczba”51
Przykładowy przebieg gry „Zgadnij, jaka to liczba”51
Importowanie modułu random53
Generowanie liczb losowych za pomocą funkcji random.randint()54
Powitanie gracza55
Instrukcje związane z przepływem sterowania56
Grupowanie w bloki56
Używanie pętli do powtarzania kodu56
Pętle z instrukcjami for57
Konwersja wartości za pomocą funkcji int(), float() i str()59
Wczytywanie próby gracza59
Logiczny typ danych61
Operatory porównania62
Sprawdzanie warunku za pomocą instrukcji warunkowych62
Eksperymentowanie z wartościami logicznymi, operatorami porównania i warunkami63
Różnica między = i ==64
Instrukcje if65
Sprawdzanie, czy gracz wygrał65
Wcześniejsze wychodzenie z pętli za pomocą instrukcji break65
Sprawdzanie, czy gracz przegrał66
Podsumowanie67
4 PROGRAM OPOWIADAJĄCY DOWCIPY70
Kilka przykładowych dowcipów71
Kod źródłowy programu „Dowcipy”71
Jak działa ten kod72
Znaki ucieczki72
Apostrofy i cudzysłowy73
Parametr end funkcji print()74
Podsumowanie75
5 „SMOCZA KRAINA”76
Zasady gry w „Smoczą krainę”76
Przykładowy przebieg gry „Smocza kraina”77
Schemat blokowy „Smoczej krainy”77
Kod źródłowy „Smoczej krainy”78
Funkcje w grze „Smocza kraina”80
Importowanie modułów random i time80
Instrukcje def80
Gdzie umieszczać definicje funkcji81
Wywoływanie funkcji81
Łańcuchy wielowierszowe82
Jak wykonywać pętle za pomocą instrukcji while83
Operatory logiczne83
Operator and84
Operator not85
Operator or85
Wyznaczanie wartości wyrażeń z operatorami logicznymi86
Zasięg globalny i zasięg lokalny87
Zwracane wartości87
Parametry funkcji89
Wyświetlanie wyników gry90
Decydowanie, w której jaskini mieszka przyjazny smok91
Główna pętla gry92
Wywoływanie funkcji w programie92
Pytanie gracza, czy chce zagrać po raz kolejny93
Podsumowanie94
6 KORZYSTANIE Z DEBUGERA96
Rodzaje błędów97
Debuger98
Uruchamianie debugera98
Krok po kroku w trybie debugera100
Znajdowanie błędów103
Ustawianie pułapek106
Korzystanie z pułapek107
Podsumowanie109
7 PROJEKTOWANIE GRY „SZUBIENICA” Z UŻYCIEM SCHEMATÓW BLOKOWYCH110
Przykładowy przebieg gry „Szubienica”111
Zasady gry w „Szubienicę”111
Grafika ASCII112
Projektowanie programu z użyciem schematu blokowego113
Tworzenie schematu blokowego114
Rozgałęzienia w schemacie blokowym115
Kończenie lub restartowanie gry116
Powtórne zgadywanie117
Informacja zwrotna dla gracza119
Podsumowanie120
8 PISANIE KODU GRY „SZUBIENICA”122
Kod źródłowy gry „Szubienica”123
Importowanie modułu random126
Listy jako typ danych127
Stałe127
Dostęp do elementów przez indeksy128
Konkatenacja list129
Wywoływanie metod130
Operator in130
Metoda łańcuchowa split()131
Metody listowe reverse() i append()131
Wczytywanie tajnego słowa z listy132
Wyświetlanie planszy133
Funkcje list() i range()134
Przycinanie list i łańcuchów135
Wyświetlanie tajnego słowa z podkreśleniami136
Wczytywanie strzału gracza138
Metody łańcuchowe lower() i upper()138
Instrukcje elif140
Opuszczanie pętli while140
Sprawdzanie, czy gracz podał prawidłową literę141
Pytanie gracza, czy chce zagrać ponownie142
Główna pętla gry143
Przegląd funkcji w grze „Szubienica”143
Sprawdzanie, czy gracz wygrał144
Sprawdzanie, czy litera znajduje się w tajnym słowie144
Umożliwienie graczowi podania litery144
Wywoływanie funkcji wyświetlPlanszę()144
Obsługa nieudanej próby odgadnięcia145
Sprawdzanie, czy gracz przegrał146
Podsumowanie147
Kończenie lub resetowanie gry147
9 ROZBUDOWA GRY „SZUBIENICA”148
Słowniki jako typ danych149
Zwiększanie liczby dozwolonych prób149
Poznawanie rozmiarów słowników za pomocą funkcji len()150
Różnica między słownikami i listami151
Korzystanie ze słowników w grze „Szubienica”152
Metody słownikowe keys() i values()152
Losowe wybieranie z listy153
Usuwanie elementów z listy154
Przypisanie wielokrotne156
Wyświetlanie informacji o kategorii słowa157
Podsumowanie158
10 „KÓŁKO I KRZYŻYK”160
Przykładowy przebieg gry w „Kółko i krzyżyk”161
Kod źródłowy gry w „Kółko i krzyżyk”162
Projektowanie programu167
Przedstawienie planszy w postaci danych167
Tworzenie strategii dla sztucznej inteligencji168
Importowanie modułu random169
Wyświetlanie planszy na ekranie169
Umożliwienie graczowi wyboru znaku X lub O170
Ustalanie, kto wykonuje pierwszy ruch171
Umieszczanie znaku na planszy172
Odwołania do list172
Odwołania do list w funkcji wykonajRuch()175
Sprawdzanie, czy gracz wygrał176
Duplikacja danych planszy178
Sprawdzanie, czy pole na planszy jest wolne179
Umożliwianie graczowi wykonania ruchu179
Wyznaczanie wartości „na skróty”180
Wybieranie ruchu z listy182
Wartość None183
Tworzenie sztucznej inteligencji (SI)184
Sprawdzanie, czy gracz może wygrać w jednym ruchu185
Sprawdzanie, czy komputer może wygrać w jednym ruchu185
Sprawdzanie pól narożnych, środkowego i bocznych (w tej właśnie kolejności)186
Główna pętla gry187
Sprawdzanie, czy na planszy są jeszcze wolne pola187
Ruch gracza188
Wybór znaku gracza i ustalenie rozpoczynającego188
Ruch komputera189
Podsumowanie190
Pytanie gracza, czy chce zagrać ponownie190
11 DEDUKCYJNA GRA „BAGELS”192
Przykładowy przebieg gry „Bagels”193
Kod źródłowy gry „Bagels”194
Schemat blokowy gry „Bagels”196
Importowanie modułu random i definiowanie funkcji uzyskajTajnąLiczbę()197
Przestawianie kolejności cyfr197
Zmiana kolejności elementów na liście za pomocą funkcji random.shuffle()197
Uzyskiwanie tajnej liczby z przestawionych cyfr198
Skrótowe operatory przypisania199
Ustalanie, jaką podpowiedź wyświetlić200
Metoda listowa sort()201
Metoda łańcuchowa join()202
Sprawdzanie, czy łańcuch zawiera jedynie cyfry202
Rozpoczynanie gry203
Interpolacja łańcuchów204
Główna pętla gry205
Sprawdzanie, czy gracz wygrał albo przegrał206
Ustalanie podpowiedzi do strzału gracza206
Wczytywanie próby odgadnięcia206
Podsumowanie207
Pytanie gracza, czy chce zagrać ponownie207
12 UKŁAD WSPÓŁRZĘDNYCH KARTEZJAŃSKICH210
Siatki i współrzędne kartezjańskie211
Liczby ujemne213
Układ współrzędnych na ekranie komputera214
Sztuczki matematyczne215
Sztuczka 1: Minus pożera znak plusa znajdujący się po jego lewe j stronie215
Sztuczka 2: Dwa minusy łączą się w plus216
Sztuczka 3: Dwie dodawane liczby mogą zamienić się miejscami216
Podsumowanie217
Wartości bezwzględne i funkcja abs()217
13 GRA „POSZUKIWANIE SKARBU SONAREM”220
Przykładowy przebieg gry „Poszukiwanie skarbu sonarem”222
Kod źródłowy gry „Poszukiwanie skarbu sonarem”224
Importowanie modułów random, sys i math230
Projektowanie programu230
Tworzenie nowej planszy do gry231
Rysowanie planszy do gry232
Rysowanie współrzędnych x wzdłuż górnej krawędzi planszy233
Rysowanie oceanu234
Wyświetlanie rzędu oceanu234
Tworzenie losowych skrzyń ze skarbami235
Rysowanie współrzędnych x na dole planszy235
Ustalanie, czy ruch jest prawidłowy236
Wykonywanie ruchu na planszy237
Znajdowanie najbliższej skrzyni ze skarbami237
Usuwanie wartości za pomocą listowej metody remove()240
Wczytywanie ruchu gracza241
Główna pętla gry243
Wyświetlanie instrukcji gry dla gracza243
Obsługa ruchu gracza245
Wyświetlanie informacji o stanie gry245
Sprawdzanie, czy gracz wygrał246
Znajdowanie zatopionej skrzyni ze skarbami246
Kończenie programu za pomocą funkcji sys.exit()247
Sprawdzanie, czy gracz przegrał247
Podsumowanie248
14 „SZYFR CEZARA”250
Kryptografia i szyfrowanie251
Jak działa szyfr Cezara252
Przykładowe działanie programu „Szyfr Cezara”253
Kod źródłowy programu „Szyfr Cezara”254
Ustawianie maksymalnej długości klucza255
Podejmowanie decyzji o zaszyfrowaniu lub odszyfrowaniu wiadomości256
Wczytywanie tekstu podanego przez gracza256
Szyfrowanie lub odszyfrowywanie komunikatu257
Wczytywanie klucza podanego przez gracza257
Znajdowanie przekazanych łańcuchów za pomocą metody find()258
Szyfrowanie lub odszyfrowywanie każdej litery259
Uruchamianie programu260
Dodawanie trybu siłowego łamania kodu261
Technika siłowa261
Podsumowanie263
15 GRA „REVERSEGAM”264
Jak grać w „Reversegam”265
Przykładowy przebieg gry „Reversegam”268
Kod źródłowy gry „Reversegam”270
Importowanie modułów i konfiguracja stałych277
Struktura danych z planszą gry277
Rysowanie struktury danych z planszą na ekranie278
Sprawdzanie, czy ruch jest prawidłowy279
Tworzenie nowej struktury danych z planszą279
Sprawdzanie każdego z ośmiu kierunków280
Sprawdzanie, czy są jakieś pionki do odwrócenia282
Sprawdzanie poprawności podanych współrzędnych283
Uzyskiwanie listy wszystkich możliwych ruchów284
Wywoływanie funkcji bool()285
Uzyskiwanie wyniku z planszy286
Wczytywanie wyboru pionka przez gracza286
Umieszczanie pionka na planszy287
Ustalanie, kto ma wykonać pierwszy ruch287
Kopiowanie struktury danych z planszą288
Ustalanie, czy pole narożne jest wolne288
Wczytywanie ruchu gracza289
Ustalanie ruchu komputera291
Strategiczne znaczenie pól narożnych291
Uzyskiwanie listy najlepszych ruchów292
Rozpoczynanie gry293
Wyświetlanie wyników na ekranie293
Sprawdzanie możliwości wykonania ruchu294
Tura gracza294
Tura komputera296
Główna pętla gry297
Pytanie gracza, czy chce zagrać ponownie298
Podsumowanie299
16 SYMULACJA SI W GRZE „REVERSEGAM”300
Komputer ma grać sam ze sobą301
Kod źródłowy symulacji 1302
Przykładowy przebieg symulacji 1302
Usuwanie tekstów wyświetlanych graczowi i dodawanie komputerowego gracza304
Komputer ma zagrać sam ze sobą wiele razy305
Przykładowy przebieg symulacji 2305
Kod źródłowy symulacji 2306
Śledzenie wielu gier307
Procentowa ocena wyników SI308
Zasłanianie wywołań funkcji print() komentarzem308
Porównywanie różnych algorytmów SI310
Kod źródłowy symulacji 3311
Jak działa SI w symulacji 3312
Porównanie SI316
Podsumowanie318
17 TWORZENIE GRAFIKI320
„Hello World” w module pygame321
Instalowanie modułu pygame321
Przykładowy przebieg programu „Hello World” napisanego z użyciem pygame322
Kod źródłowy programu „Hello World” w wersji pygame323
Importowanie modułu pygame324
Inicjalizacja pygame325
Konfiguracja okna pygame325
Krotki326
Obiekty Surface326
Konfiguracja zmiennych z kolorami327
Wypisywanie tekstu w oknie pygame328
Używanie czcionek do stylizacji tekstu328
Renderowanie obiektu Font329
Ustawianie położenia tekstu za pomocą atrybutów Rect330
Funkcje związane z rysowaniem w module pygame332
Wypełnianie obiektu Surface kolorem332
Rysowanie wielokąta332
Rysowanie linii333
Rysowanie elipsy334
Rysowanie okręgu334
Rysowanie prostokąta335
Metoda blit() dla obiektów Surface336
Kolorowanie pikseli336
Rysowanie obiektu Surface na ekranie337
Zdarzenia i główna pętla gry337
Opuszczanie programu338
Uzyskiwanie obiektów Event338
Podsumowanie339
18 GRAFIKA ANIMOWANA340
Kod źródłowy programu „Animacja”341
Przykładowy przebieg programu „Animacja”341
Przemieszczanie i odbijanie się ramek od krawędzi okna343
Konfiguracja stałych344
Stałe reprezentujące kierunki345
Konfiguracja struktur danych z ramkami346
Stałe oznaczające kolory346
Główna pętla gry347
Kod pozwalający wyjść z gry347
Przemieszczanie każdej ramki348
Odbijanie się ramek od krawędzi okna349
Rysowanie ramek w oknie w nowym położeniu350
Podsumowanie351
Rysowanie okna na ekranie351
19 WYKRYWANIE KOLIZJI352
Przykładowy przebieg programu „Wykrywania kolizji”353
Kod źródłowy programu „Wykrywanie kolizji”354
Importowanie modułów356
Konfiguracja okna i struktur danych357
Sterowanie szybkością programu za pomocą obiektu Clock357
Konfiguracja zmiennych do śledzenia ruchu359
Obsługa zdarzeń359
Obsługa zdarzenia KEYDOWN360
Teleportowanie gracza363
Obsługa zdarzenia KEYUP363
Dodawanie nowych kwadracików z pożywieniem364
Poruszanie postacią gracza w obrębie okna365
Rysowanie postaci gracza w oknie365
Sprawdzanie, czy wystąpiła kolizja366
Podsumowanie367
Rysowanie w oknie kwadracików pożywienia367
20 WYKORZYSTYWANIE DŹWIĘKÓW I OBRAZKÓW368
Dodawanie obrazów za pomocą duszków369
Pliki dźwiękowe i obrazkowe369
Przykładowy przebieg programu „Duszki i dźwięki”370
Kod źródłowy programu „Duszki i dźwięki”371
Konfiguracja okna i struktury danych374
Dodawanie duszka374
Konfigurowanie muzyki i dźwięków375
Dodawanie plików dźwiękowych375
Zmiana rozmiaru duszka375
Rysowanie w oknie postaci gracza376
Włączanie i wyłączanie dźwięku376
Sprawdzanie kolizji377
Podsumowanie378
Rysowanie czereśni w oknie378
21 „DODGER” – GRA Z OBRAZEM I DŹWIĘKIEM380
Powtórka z podstawowych typów danych pygame381
Kod źródłowy gry „Dodger”382
Przykładowy przebieg gry „Dodger”382
Importowanie modułów387
Konfiguracja stałych388
Definiowanie funkcji389
Zatrzymywanie i pauzowanie gry389
Sprawdzanie kolizji z paskudami390
Inicjalizacja pygame i konfiguracja okna391
Rysowanie tekstu w oknie391
Konfiguracja obiektów Font, Sound i Image392
Wyświetlanie ekranu startowego393
Rozpoczynanie gry394
Główna pętla gry396
Obsługa zdarzeń klawiatury396
Dodawanie nowych paskud398
Obsługa ruchów myszy398
Poruszanie postacią gracza i paskudami400
Implementacja kodów oszukiwania401
Rysowanie okna402
Usuwanie paskud402
Rysowanie postaci gracza oraz paskud403
Wyświetlanie wyniku gracza403
Ekran z napisem Game Over404
Sprawdzanie kolizji404
Modyfikowanie gry „Dodger”405
Podsumowanie406
SKOROWIDZ408

Importowaniemodułurandom00000000000000000000000000000000000000000000000024

Generowanieliczblosowychzapomocąfunkcjirandom0randint()0000000000000000000000025

Powitaniegracza000000000000000000000000000000000000000000000000000000000026

Instrukcjezwiązanezprzepływemsterowania000000000000000000000000000000000000027

Używaniepętlidopowtarzaniakodu000000000000000000000000000000000027

Grupowaniewbloki00000000000000000000000000000000000000000000027

Pętlezinstrukcjamifor0000000000000000000000000000000000000000000028

Wczytywaniepróbygracza00000000000000000000000000000000000000000000000000030

Konwersjawartościzapomocąfunkcjiint(),ﬂoat()istr()00000000000000000000000000000030

Logicznytypdanych000000000000000000000000000000000000000000000000000000032

Operatoryporównania000000000000000000000000000000000000000000033

Sprawdzaniewarunkuzapomocąinstrukcjiwarunkowych00000000000000000033

Eksperymentowaniezwartościamilogicznymi,operatoramiporównaniaiwarunkami00034

Różnicamiędzy=i==000000000000000000000000000000000000000000035

Instrukcjeif0000000000000000000000000000000000000000000000000000000000000036

Wcześniejszewychodzeniezpętlizapomocąinstrukcjibreak0000000000000000000000000036

Sprawdzanie,czygraczwygrał00000000000000000000000000000000000000000000000036

Sprawdzanie,czygraczprzegrał000000000000000000000000000000000000000000000037

Podsumowanie0000000000000000000000000000000000000000000000000000000000038

PROGRAMOPOWIADAJĄCYDOWCIPY

Kilkaprzykładowychdowcipów0000000000000000000000000000000000000000000000042

Kodźródłowyprogramu„Dowcipy”0000000000000000000000000000000000000000000042

Jakdziałatenkod00000000000000000000000000000000000000000000000000000000043

Znakiucieczki00000000000000000000000000000000000000000000000000000000000043

Apostrofyicudzysłowy00000000000000000000000000000000000000000000000000000044

Parametrendfunkcjiprint()0000000000000000000000000000000000000000000000000045

Podsumowanie0000000000000000000000000000000000000000000000000000000000046

„SMOCZAKRAINA”

Zasadygryw„Smocząkrainę”00000000000000000000000000000000000000000000000047

Przykładowyprzebieggry„Smoczakraina”00000000000000000000000000000000000000048

Schematblokowy„Smoczejkrainy”0000000000000000000000000000000000000000000048

Kodźródłowy„Smoczejkrainy”0000000000000000000000000000000000000000000000049

Importowaniemodułówrandomitime00000000000000000000000000000000000000000051

Funkcjewgrze„Smoczakraina”0000000000000000000000000000000000000000000000051

Instrukcjedef00000000000000000000000000000000000000000000000000051

Wywoływaniefunkcji00000000000000000000000000000000000000000000052

Gdzieumieszczaćdefnicjefunkcji0000000000000000000000000000000000052

Łańcuchywielowierszowe000000000000000000000000000000000000000000000000000053

Jakwykonywaćpętlezapomocąinstrukcjiwhile0000000000000000000000000000000000054

Operatorylogiczne0000000000000000000000000000000000000000000000000000000054

Operatorand0000000000000000000000000000000000000000000000000055

Operatoror00000000000000000000000000000000000000000000000000056

Operatornot00000000000000000000000000000000000000000000000000056

Wyznaczaniewartościwyrażeńzoperatoramilogicznymi000000000000000000057

Zwracanewartości0000000000000000000000000000000000000000000000000000000058

VIIISzczegółowyspistreści

Brak wyników

Twórz własne gry komputerowe w Pythonie

Treść książki

Znajdź bibliotekę blisko siebie, i uzyskaj dostęp do ebooka w systemie IBUK Libra