Tytuł oryginału: Raspberry Pi Project
Tłumaczenie: Tomasz Walczak
ISBN: 978-83-246-9221-7
© 2014 John Wiley & Sons, Ltd.
All Rights Reserved. Authorised translation from the English language edition published by John Wiley &
Sons Limited. Responsibility for the accuracy of the translation rests solely with Helion S.A. and is not the
responsibility of John Wiley & Sons Limited.
No part of this book may be reproduced in any form without the written permission of the original
copyright holder, John Wiley & Sons Limited.
Translation copyright © 2014 by Helion S.A.
Designations used by companies to distinguish their products are often claimed as trademarks. All brand
names and product names used in this book are trade names, service marks, trademarks or registered
trademarks of their respective owners. The publisher is not associated with any product or vendor
mentioned in this book. is publication is designed to provide accurate and authoritative information in
regard to the subject matter covered. It is sold on the understanding that the publisher is not engaged in
rendering professional services. If professional advice or other expert assistance is required, the services of
a competent professional should be sought.
Wiley and the John Wiley & Sons, Ltd. logo are trademarks or registered trademarks of John Wiley and
Sons, Ltd. and/ or its affiliates in the United States and/or other countries, and may not be used without
written permission. Raspberry Pi is a trademark of the Raspberry Pi Foundation. All other trademarks are
the property of their respective owners. John Wiley & Sons, Ltd. is not associated with any product or
vendor mentioned in the book.
Wszelkie prawa zastrzeżone. Nieautoryzowane rozpowszechnianie całości lub fragmentu niniejszej
publikacji w jakiejkolwiek postaci jest zabronione. Wykonywanie kopii metodą kserograficzną,
fotograficzną, a także kopiowanie książki na nośniku filmowym, magnetycznym lub innym powoduje
naruszenie praw autorskich niniejszej publikacji.
Wszystkie znaki występujące w tekście są zastrzeżonymi znakami firmowymi bądź towarowymi ich
właścicieli.
Autor oraz Wydawnictwo HELION dołożyli wszelkich starań, by zawarte w tej książce informacje były
kompletne i rzetelne. Nie biorą jednak żadnej odpowiedzialności ani za ich wykorzystanie, ani za związane
z tym ewentualne naruszenie praw patentowych lub autorskich. Autor oraz Wydawnictwo HELION nie
ponoszą również żadnej odpowiedzialności za ewentualne szkody wynikłe z wykorzystania informacji
zawartych w książce.
Wydawnictwo HELION
ul. Kościuszki 1c, 44-100 GLIWICE
tel. 32 231 22 19, 32 230 98 63
e-mail: helion@helion.pl
WWW: http://helion.pl (księgarnia internetowa, katalog książek)
Drogi Czytelniku!
Jeżeli chcesz ocenić tę książkę, zajrzyj pod adres
http://helion.pl/user/opinie/raspnp
Możesz tam wpisać swoje uwagi, spostrzeżenia, recenzję.
Printed in Poland.
Spis treĂci
Wprowadzenie .......................................................................................... 13
Historia powstania ................................................................................................13
Informatyka uĝytkowa ..........................................................................................14
Dlaczego wszyscy powinni uczyÊ siÚ informatyki? ..............................................14
Poznaj Raspberry Pi ...............................................................................................15
O tej ksiÈĝce ...........................................................................................................16
Jak korzystaÊ z tej ksiÈĝki? ...................................................................................17
PrzyszïoĂÊ ..............................................................................................................19
CzÚĂÊ I: Wprowadzenie do Raspberry Pi .................................. 21
ROZDZIA 1
Uruchamianie Raspberry Pi .................................................................... 23
System operacyjny .................................................................................................24
PodïÈczanie Raspberry Pi ......................................................................................30
Proces ïadowania ...................................................................................................38
Uruchamianie interfejsu graficznego ....................................................................39
Uruchamianie terminala w Ărodowisku X ............................................................39
RozwiÈzywanie problemów ..................................................................................40
Pora rozpoczÈÊ zabawÚ! ........................................................................................42
ROZDZIA 2
WprowadzajÈcy projekt oprogramowania — generator obelg ........... 43
Uruchamianie pierwszego programu w Pythonie ................................................44
Zapisywanie programu ..........................................................................................46
Generowanie obelg ................................................................................................48
Imienne obraĝanie znajomych ..............................................................................51
Tworzenie strumienia obelg ..................................................................................53
Èczenie wszystkich elementów ...........................................................................56
CzÚĂÊ II: Projekty oprogramowania .......................................... 59
ROZDZIA 3
Kóïko i krzyĝyk .......................................................................................... 61
BïÚdy ......................................................................................................................62
PoczÈtek .................................................................................................................63
Gra dla dwóch zawodników ..................................................................................67
Gra przeciw komputerowi .....................................................................................70
Twoja kolej .............................................................................................................79
ROZDZIA 4
Oto przeglÈd najnowszych wiadomoĂci ................................................. 81
Pierwsze telepromptery ........................................................................................82
Pi Prompter ............................................................................................................83
8
RASPBERRY PI. NAJLEPSZE PROJEKTY
Czego potrzebujesz? .............................................................................................. 83
Krok bliĝej do uĝytecznego programu .................................................................. 88
Gotowy kod programu Pi Prompter ..................................................................... 92
Fizyczna budowa telepromptera .......................................................................... 96
Twoja kolej ............................................................................................................ 99
ROZDZIA 5
Ping ........................................................................................................... 101
Wczesne produkty komercyjne .......................................................................... 102
Gra Ping ............................................................................................................... 103
Ulepszanie gry Ping ............................................................................................ 107
Gra dla jednej osoby ............................................................................................ 111
Wersja dla dwóch graczy .................................................................................... 117
Twoja kolej .......................................................................................................... 123
ROZDZIA 6
Pie Man .................................................................................................... 125
Pie Man ............................................................................................................... 126
Tworzenie zasobów ............................................................................................ 127
Przygotowywanie planszy .................................................................................. 131
Przebieg gry ........................................................................................................ 135
WyĂwietlanie zawartoĂci ekranu ....................................................................... 142
Ostatnia funkcja .................................................................................................. 144
Twoja kolej .......................................................................................................... 149
ROZDZIA 7
Generowanie labiryntów w Minecrafcie ............................................ 151
Instalowanie Minecrafta .................................................................................... 152
Uruchamianie Minecrafta .................................................................................. 153
Gra w Minecrafta ................................................................................................ 154
Przygotowania do uĝycia Pythona ..................................................................... 156
Uĝywanie moduïu Minecrafta ............................................................................ 156
Twoja kolej .......................................................................................................... 172
CzÚĂÊ III: Projekty sprzÚtowe ................................................... 173
ROZDZIA 8
Kolorowa wersja gry Snap ..................................................................... 175
Implementowanie gry ......................................................................................... 176
Teoria .................................................................................................................. 176
Oprogramowanie do testowania gry .................................................................. 189
Oprogramowanie gry .......................................................................................... 192
Twoja kolej .......................................................................................................... 196
ROZDZIA 9
Sprawdě swój czas reakcji .................................................................... 197
Witaj w Ăwiecie systemów wbudowanych! ....................................................... 198
Pozyskiwanie komponentów .............................................................................. 199
Konfigurowanie karty PiFace Digital ................................................................. 200
PodïÈczanie karty PiFace Digital ........................................................................ 204
SPIS TRE¥CI
9
Uĝywanie emulatora ...........................................................................................204
Komunikowanie siÚ z Pythonem .........................................................................205
Stoper do pomiaru czasu reakcji .........................................................................208
Co podïÈczysz do komputera? .............................................................................218
ROZDZIA 10
TwittujÈca zabawka ............................................................................... 219
„Hakowanie” zabawki .........................................................................................220
Jak zmusiÊ zabawkÚ do mówienia? ....................................................................224
Poruszanie zabawkÈ ............................................................................................227
Èczenie siÚ z Twitterem ....................................................................................230
Èczenie wszystkich elementów .........................................................................235
Podsumowanie .....................................................................................................238
ROZDZIA 11
¥wiatïa dyskotekowe ............................................................................. 241
Definiowanie sekwencji Ăwiateï .........................................................................242
Kod wykonujÈcy inne operacje ............................................................................244
TrochÚ teorii ........................................................................................................246
Projektowanie sekwensera ..................................................................................247
Implementowanie sekwensera ............................................................................248
OĂwietlenie ..........................................................................................................254
Uĝywanie dïuĝszych taĂm LED ...........................................................................256
RuszajÈce siÚ Ăwiatïa ...........................................................................................258
Uruchamianie obwodu ........................................................................................262
Twoja kolej ...........................................................................................................262
ROZDZIA 12
Zamek do drzwi ...................................................................................... 263
Ogólne omówienie systemu .................................................................................264
Systemy krytyczne ze wzglÚdu na bezpieczeñstwo ...........................................265
Zamek do drzwi ...................................................................................................266
WstÚpna wysokopoziomowa symulacja programowa ........................................267
Blok wyjĂciowy ....................................................................................................268
Blok do pobierania danych wejĂciowych ............................................................271
Blok uwierzytelniajÈcy uĝytkownika .................................................................271
Odblokowywanie drzwi bez ich dotykania .........................................................273
Testowanie programu i mocowanie zamka ........................................................278
Èczenie wielu drzwi w sieci ..............................................................................279
Twoja kolej ...........................................................................................................280
Sztuka programowania .......................................................................................281
ROZDZIA 13
Automatyzowanie domu ........................................................................ 283
IOT .......................................................................................................................284
Projekt 1. Jak zbudowaÊ czujnik ruchu oraz wyïÈcznik drzwiowy? .................284
Projekt 2. Monitorowanie domu za pomocÈ kamery internetowej ....................290
Projekt 3. Budowanie termometru ......................................................................296
Projekt 4. Wysyïanie e-maili z powiadomieniami ..............................................300
Projekt 5. Wysyïanie e-maili za pomocÈ pilota bezprzewodowego ...................306
Twoja kolej ...........................................................................................................311
10
RASPBERRY PI. NAJLEPSZE PROJEKTY
ROZDZIA 14
Komputerowe sterowanie elektronikÈ toru z samochodzikami ...... 313
Kupno toru z samochodzikami ........................................................................... 314
PodïÈczanie toru z samochodzikami .................................................................. 314
Testowanie poïÈczeñ z torem ............................................................................. 316
Pobieranie danych od graczy .............................................................................. 316
Oprogramowanie ................................................................................................. 325
Kod gry ................................................................................................................ 327
Twoja kolej .......................................................................................................... 332
ROZDZIA 15
Generowanie grafiki i zamieszczanie jej na Facebooku .................... 333
Pomysï ................................................................................................................. 334
Rodzaje enkoderów obrotowych ........................................................................ 334
Dane wyjĂciowe z enkodera ............................................................................... 335
Przesyïanie rysunków do Facebooka ................................................................. 342
Ostateczna wersja programu Roto-Sketch ......................................................... 346
Tworzenie symetrycznych wzorów ................................................................... 351
Twoja kolej .......................................................................................................... 355
ROZDZIA 16
Harmonograf ........................................................................................... 357
Pomysï ................................................................................................................. 359
Efekt Halla .......................................................................................................... 359
Poznaj Arduino .................................................................................................... 361
Èczenie róĝnych elementów ............................................................................. 362
Programowanie Arduino ..................................................................................... 372
Programowanie Raspberry Pi ............................................................................. 383
Uĝywanie programu Pendulum Pi ..................................................................... 388
Twoja kolej .......................................................................................................... 388
ROZDZIA 17
Zaawansowana budka dla ptaków — obserwowanie przyrody ....... 391
Budowanie niewidocznych czujników promieni ............................................... 393
Montowanie czujników ...................................................................................... 397
Zapisywanie aktywnoĂci ptaków w pliku .......................................................... 400
Przetwarzanie danych ........................................................................................ 410
Radzenie sobie z szumem z czujników .............................................................. 415
Rysowanie wykresu ............................................................................................ 420
WïÈczanie budki ................................................................................................. 422
Twoja kolej .......................................................................................................... 423
MoĝliwoĂci sÈ nieograniczone ............................................................................ 424
Skorowidz ................................................................................................ 425
Rozdziaï
7
Generowanie labiryntów
w Minecrafcie
Sean McManus
W tym rozdziale:
P
Instalowanie Minecrafta
P
Poznawanie Ăwiata Minecrafta
P
Manipulowanie Ăwiatem Minecrafta w Pythonie
P
Generowanie losowego labiryntu Minecrafta za pomocÈ Pythona
152
RASPBERRY PI. NAJLEPSZE PROJEKTY
Minecraft jest popularny wĂród fanów klocków Lego z caïego Ăwiata. Pozwala
tworzyÊ z bloków wciÈgajÈce trójwymiarowe Ăwiaty i rozpala wyobraěniÚ do tego
stopnia, ĝe zgodnie z szacunkami sprzedano okoïo 20 milionów egzemplarzy tej gry
na róĝne platformy (w tym na komputery PC i konsole Xbox).
DostÚpna jest takĝe wersja alfa tej gry przeznaczona na Raspberry Pi. DostÚpny jest
w niej tylko tryb tworzenia, w którym moĝna bezpiecznie budowaÊ Ăwiat bez za-
groĝenia gïodem lub atakami potworów. Wersja ta ma teĝ ciekawÈ cechÚ — moĝna
jÈ programowaÊ za pomocÈ róĝnych jÚzyków, w tym Pythona. Oznacza to, ĝe da siÚ
zbudowaÊ wielki païac bez koniecznoĂci rÚcznego dodawania wszystkich bloków.
Moĝna teĝ, co przedstawiam w tym rozdziale, pisaÊ programy wymyĂlajÈce orygi-
nalne, nowe struktury, a nastÚpnie zwiedzaÊ i eksplorowaÊ te obiekty.
W tym projekcie utworzysz w Pythonie program generujÈcy labirynty w Minecrafcie.
Przy kaĝdym uruchomieniu program generuje nowy labirynt, a uĝytkownik moĝe
kontrolowaÊ, jak duĝa ma byÊ struktura i z jakich materiaïów naleĝy jÈ zbudowaÊ.
W trakcie prac nad projektem zobaczysz, jak za pomocÈ Pythona dodawaÊ i usu-
waÊ bloki w Minecrafcie. DziÚki temu zdobÚdziesz umiejÚtnoĂci, które pozwolÈ Ci
pisaÊ wïasne programy sterujÈce budowÈ.
W czasie gdy powstawaïa ta ksiÈĝka, gra Minecraft: Pi Edition byïa dostÚpna w wer-
sji alfa. Jest to bardzo wczesna wersja testowa (jeszcze mniej zaawansowana niĝ
wersja beta). Jednak wykryïem w niej tylko kilka problemów: okno i jego zawar-
toĂÊ byïy ěle wyrównane przy rozdzielczoĂci 1024×768 (dlatego przeïÈczyïem jÈ na
1280×1024), a kursor dziaïaï nieprawidïowo po zmaksymalizowaniu okna. Mimo
to zachÚcam do tego, aby przy korzystaniu z oprogramowania w wersji alfa na wy-
padek problemów zawsze archiwizowaÊ waĝne dane z Raspberry Pi.
WSKAZÓWKA
Najïatwiejszy sposób archiwizowania plików z Raspberry Pi polega na podïÈczeniu urzÈdzenia
pamiÚci masowej i wykorzystaniu do skopiowania danych menedĝera plików dostÚpnego w Ăro-
dowisku okienkowym.
Kod do tego rozdziaïu moĝna pobraÊ z mojej witryny: http://www.sean.co.uk.
Instalowanie Minecrafta
ChoÊ Minecraft na inne platformy jest oprogramowaniem komercyjnym, wersjÚ alfa
na Raspberry Pi moĝna pobraÊ bezpïatnie. Aby móc uruchomiÊ tÚ wersjÚ, trzeba
zainstalowaÊ w Raspberry Pi dystrybucjÚ Raspbian Wheezy Linuksa. Jest to wersja
systemu zalecana przez fundacjÚ Raspberry Pi. Moĝna jÈ zainstalowaÊ za pomocÈ
obrazu NOOBS dostÚpnego w sekcji z plikami do pobrania z witryny http://www.
raspberrypi.org. Informacje na temat instalowania systemu operacyjnego znajdziesz
w rozdziale 1., „Uruchamianie Raspberry Pi”.
ROZDZIA 7. GENEROWANIE LABIRYNTÓW W MINECRAFCIE
153
Aby zainstalowaÊ Minecrafta, wykonaj nastÚpujÈce czynnoĂci:
1.
Upewnij siÚ, ĝe Raspberry Pi jest podïÈczony do internetu. Minecrafta pobie-
rzesz przez poïÈczenie internetowe.
2.
Uruchom Raspberry Pi, wpisz polecenie startx i wciĂnij klawisz Enter, aby
otworzyÊ Ărodowisko okienkowe.
3.
Kliknij dwukrotnie ikonÚ Midori w Ărodowisku okienkowym lub uĝyj menu
Programs w lewym dolnym rogu, aby uruchomiÊ przeglÈdarkÚ internetowÈ.
4.
Otwórz stronÚ http://pi.minecraft.net i kliknij odnoĂnik, aby pobraÊ Minecrafta.
W oknie dialogowym kliknij przycisk Save As i zapisz plik w katalogu pi. W prze-
glÈdarce plików katalog ten powinien byÊ wyróĝniony w widocznej po lewej
stronie sekcji Places. Kliknij przycisk Save i zamknij przeglÈdarkÚ Midori (nie
bÚdziesz juĝ jej potrzebowaï).
5.
Kliknij dwukrotnie ikonÚ programu LXTerminal na pulpicie, aby uruchomiÊ
sesjÚ terminala.
6.
Wprowadě instrukcjÚ tar –zxvf minecraft-pi-0.1.1.tar.gz, aby wypakowaÊ
zawartoĂÊ pobranego pliku. W Linuksie wielkoĂÊ znaków ma znaczenie, dlatego
koniecznie uĝyj samych maïych liter. Ostatni czïon polecenia to nazwa pobra-
nego pliku. Moĝe siÚ ona zmieniÊ (zwïaszcza koñcowe numery), gdy pojawiÈ
siÚ nowe wersje Minecrafta. Wystarczy wpisaÊ kilka pierwszych liter nazwy
i wcisnÈÊ klawisz Tab, aby komputer automatycznie jÈ uzupeïniï. W trakcie
wypakowywania plików ich nazwy bÚdÈ pojawiaÊ siÚ na ekranie. W celu wy-
Ăwietlenia zawartoĂci katalogu pi wpisz instrukcjÚ ls.
7.
Wprowadě polecenie cd mcpi, aby przejĂÊ do katalogu z wypakowanymi plikami
Minecrafta.
8.
Wpisz instrukcjÚ ./minecraft-pi i wciĂnij klawisz Enter, aby uruchomiÊ grÚ.
JeĂli wszystko przebiegïo prawidïowo, powinieneĂ zobaczyÊ ekran tytuïowy
Minecrafta.
Uruchamianie Minecrafta
Gdy po zainstalowaniu Minecrafta zechcesz ponownie go uruchomiÊ, przejdě do
Ărodowiska okienkowego (krok 2. w instrukcjach instalacji w podrozdziale „Insta-
lowanie Minecrafta”), rozpocznij sesjÚ terminala (krok 5.) i wpisz polecenie cd mcpi,
a nastÚpnie ./minecraft-pi. Nie moĝna uruchomiÊ Minecrafta z poziomu wiersza
poleceñ bez wczeĂniejszego otwarcia Ărodowiska okienkowego.
WSKAZÓWKA
JeĂli zamkniesz okno programu LXTerminal, natychmiast zakoñczysz sesjÚ Minecrafta. Dlatego
spróbuj ignorowaÊ to okno, które na pozór nic nie robi — jest ono potrzebne.
154
RASPBERRY PI. NAJLEPSZE PROJEKTY
Gra w Minecrafta
Gdy uruchomisz Minecrafta w Raspberry Pi, na ekranie powitalnym bÚdziesz mógï
wybraÊ jednÈ z dwóch opcji:
P
Start Game (rozpoczÚcie gry). Z tej opcji bÚdziesz korzystaï w tym rozdziale
do generowania wïasnych Ăwiatów, które moĝna eksplorowaÊ. Za jej pomo-
cÈ moĝesz teĝ wybraÊ wczeĂniej wygenerowany Ăwiat, gdy ponownie uru-
chomisz Minecrafta. Aby wybraÊ jeden ze Ăwiatów, kliknij je i przeciÈgnij,
tak aby potrzebny Ăwiat znalazï siÚ poĂrodku. NastÚpnie kliknij na nim, aby
go otworzyÊ.
P
Join Game (doïÈczanie do gry). Ta opcja pozwala doïÈczyÊ do innych graczy
w sieci lokalnej. Omawianie tego trybu wykracza poza zakres rozdziaïu. Ta
opcja umoĝliwia wspóïpracÚ lub rywalizacjÚ w Ăwiecie Minecrafta.
Kliknij przycisk Start Game, a nastÚpnie wybierz opcjÚ Create New. Minecraft wy-
generuje wtedy nowy Ăwiat z wyjÈtkowym ukïadem gór, lasów i oceanów. Po zakoñ-
czeniu tego procesu zobaczysz Ăwiat z perspektywy pierwszej osoby (rysunek 7.1).
Rysunek 7.1.
Microsoft
w Raspberry Pi
WSKAZÓWKA
Moĝesz zmieniÊ perspektywÚ i zobaczyÊ postaÊ gracza. W tym celu wciĂnij klawisz Esc, aby
otworzyÊ menu gry, a nastÚpnie kliknij ikonÚ obok ikony gïoĂników w lewym górnym rogu.
Po zakoñczeniu gry moĝesz jÈ zamknÈÊ z poziomu menu gry (aby je wyĂwietliÊ,
wciĂnij klawisz Esc).
ROZDZIA 7. GENEROWANIE LABIRYNTÓW W MINECRAFCIE
155
Poruszanie siÚ po Ăwiecie
Przy grze w Minecrafta najlepiej jest uĝywaÊ obu rÈk. Jedna powinna znajdowaÊ siÚ
na myszy, a druga — na klawiaturze. Za pomocÈ myszy moĝesz siÚ rozglÈdaÊ i zmie-
niaÊ kierunek. PrzesuniÚcie myszy w lewo lub prawo pozwala siÚ obróciÊ, a ruchy
do przodu i do tyïu powodujÈ spoglÈdanie w dóï i w górÚ. Do poruszania siÚ sïuĝÈ
klawisze W (do przodu), S (do tyïu), A (w lewo) i D (w prawo). SÈ one zgrupowane
w jednym miejscu na klawiaturze, dziÚki czemu posïugiwanie siÚ nimi jest ïatwe.
PostaÊ automatycznie skacze na niĝej poïoĝone obszary, jeĂli nad nie przejdziesz.
Moĝesz teĝ celowo wykonaÊ skok (sïuĝy do tego spacja).
Aby uzyskaÊ najlepszy obraz Ăwiata, kliknij dwukrotnie spacjÚ. Ujrzysz wtedy Ăwiat
z lotu ptaka. W tym trybie wciĂniÚcie spacji pozwala wznieĂÊ siÚ wyĝej, a lewy kla-
wisz Shift sïuĝy do obniĝania pozycji. Ponowne dwukrotne klikniÚcie spacji umoĝ-
liwia powrót na ziemiÚ. W tej wersji Minecrafta nie ma ĝyÊ ani zagroĝeñ, dlatego
moĝesz bezpiecznie skakaÊ z dowolnej wysokoĂci.
Tworzenie i niszczenie obiektów
JeĂli chcesz zniszczyÊ blok, wskaĝ go myszÈ, a nastÚpnie kliknij i przytrzymaj lewy
przycisk myszy. Niektóre bloki sÈ ïatwiejsze do usuniÚcia niĝ inne. Aby zniszczyÊ
obiekt, musisz byÊ odpowiednio blisko. Dlatego jeĂli przy próbie usuniÚcia bloku
nie widzisz, jak siÚ rozpada, stañ bliĝej niego.
Panel w dolnej czÚĂci okna przedstawia bloki, które moĝesz umieĂciÊ w Ăwiecie
(zobacz rysunek 7.1). WybieraÊ bloki moĝna za pomocÈ kóïka przewijania myszy
lub klawiszy z cyframi od 1 do 8 (blokowi pierwszemu od lewej odpowiada cyfra
1 itd.). WciĂnij E, aby otworzyÊ peïnÈ listÚ materiaïów. Do poruszania siÚ po niej
sïuĝÈ klawisze sterujÈce ruchem (W, A, S, D). JeĂli chcesz wybraÊ dany blok, wci-
Ănij klawisz Enter lub kliknij go myszÈ.
Aby umieĂciÊ blok w danym miejscu, kliknij docelowÈ lokalizacjÚ prawym przyci-
skiem myszy. Blok moĝesz umieĂciÊ na innym tylko wtedy, gdy widzisz górnÈ czÚĂÊ
tego ostatniego. Dlatego przy tworzeniu wysokich budowli czasem trzeba spojrzeÊ
na Ăwiat z lotu ptaka.
WSKAZÓWKA
Moĝesz budowaÊ wieĝe i jednoczeĂnie wspinaÊ siÚ po nich. W tym celu naleĝy spoglÈdaÊ
w dóï i jednoczeĂnie podskakiwaÊ oraz dodawaÊ bloki.
ChoÊ budowanie obiektów za pomocÈ Pythona jest znacznie ïatwiejsze, zachÚcam
do zapoznania siÚ z tym, jak gracze czujÈ siÚ w Ăwiecie Minecrafta. Warto zwïasz-
cza poeksperymentowaÊ z interakcjÈ miÚdzy blokami. Bloki kamienne potrafiÈ
utrzymaÊ siÚ bez bezpoĂredniego podparcia w powietrzu, natomiast bloki z piasku
spadajÈ na powierzchniÚ. Nie moĝna sadziÊ kaktusów na trawie, moĝna jednak
156
RASPBERRY PI. NAJLEPSZE PROJEKTY
umieĂciÊ je na piasku. JeĂli usuniesz blok na brzegu jeziora, opróĝnionÈ przestrzeñ
zapeïni woda. W grze nie moĝna umieszczaÊ ěródeï wody ani lawy, choÊ moĝna
dodaÊ je programowo za pomocÈ Pythona. Woda i lawa spïywajÈ kaskadami w dóï
i zapeïniajÈ duĝe obszary. Gdy te ĝywioïy zetknÈ siÚ ze sobÈ, woda schïadza lawÚ
i zamienia jÈ w kamieñ.
Przygotowania do uĝycia Pythona
JednÈ z zaskakujÈcych cech Minecrafta jest to, ĝe gra przejmuje kontrolÚ nad myszÈ.
Dlatego trzeba wcisnÈÊ klawisz Tab, aby wróciÊ do uĝywania innych programów.
JeĂli póěniej chcesz ponownie zaczÈÊ uĝywaÊ myszy w Minecrafcie, kliknij okno gry.
Wkrótce przyzwyczaisz siÚ do wciskania klawisza Tab przed rozpoczÚciem pro-
gramowania. Teraz wciĂnij ten klawisz, aby wyjĂÊ z Minecrafta, i przenieĂ kursor
na pulpit.
Do tworzenia programów zwiÈzanych z Minecraftem posïuĝy Ărodowisko IDLE.
Kliknij dwukrotnie jego ikonÚ na pulpicie, aby je uruchomiÊ. Moĝliwe, ĝe najpierw
bÚdziesz musiaï kliknÈÊ górnÈ krawÚdě okna Minecrafta i przeciÈgnÈÊ je, ĝeby zo-
baczyÊ potrzebnÈ ikonÚ.
JednÈ z pierwszych rzeczy, jakie zauwaĝysz, jest to, ĝe Minecraft znajduje siÚ nad
innymi oknami, dlatego Ărodowisko IDLE moĝe byÊ niewidoczne. NiezbÚdna jest
wiÚc odpowiednia reorganizacja pulpitu. Aby przenieĂÊ okno, przeciÈgnij je za pasek
tytuïu. Zmienianie wielkoĂci okien odbywa siÚ w wyniku przeciÈgania krawÚdzi
i rogów. ZachÚcam, aby tak uporzÈdkowaÊ okna, aby wszystkie byïy jednoczeĂnie
widoczne. Na monitorze o standardowych wymiarach, jakiego uĝywam, umieszczam
Minecrafta w lewym górnym rogu, maïe okno z powïokÈ Pythona w prawym górnym
naroĝniku, a okno z kodem programu w dolnej czÚĂci ekranu. Nie naleĝy zmieniaÊ
wielkoĂci okna Minecrafta. W wersji, z której korzystam, gra przestaje wtedy reagowaÊ
na ruchy myszÈ. Okno programu LXTerminal moĝesz zignorowaÊ (ale go nie zamykaj).
Uĝywanie moduïu Minecrafta
Teraz moĝesz napisaÊ swój pierwszy program w Pythonie powiÈzany ze Ăwiatem
Minecrafta. Program ten bÚdzie wysyïaï komunikaty do dostÚpnego w grze czata.
W powïoce Pythona otwórz menu File i wybierz opcjÚ New, aby otworzyÊ nowe
okno edytora. Wpisz w nim poniĝszy kod, a nastÚpnie zapisz plik w katalogu pi za
pomocÈ menu File i wciĂnij klawisz F5, aby uruchomiÊ nowy program. Do dziaïa-
nia wymaga on, aby uruchomiona byïa sesja gry w Minecrafcie.
import sys, random
sys.path.append("./mcpi/api/python/mcpi")
import minecraft
mc = minecraft.Minecraft.create()
mc.postToChat("Witamy w labiryntach Minecrafta!")
ROZDZIA 7. GENEROWANIE LABIRYNTÓW W MINECRAFCIE
157
Pierwszy wiersz importuje moduïy sys i random. Moduï random bÚdzie póěniej potrzebny
do budowania losowych labiryntów. Moduï sys jest uĝywany od razu do poinformo-
wania Ărodowiska IDLE, gdzie znajduje siÚ moduï Pythona zwiÈzany z Minecraftem
(pozwala on na przekazywanie instrukcji wykonywanych w Minecrafcie). Po wska-
zaniu Ărodowisku IDLE lokalizacji tego moduïu naleĝy go zaimportowaÊ.
W Pythonie do przesyïania instrukcji do Minecrafta sïuĝy polecenie minecraft.
Minecraft.create(), po którym naleĝy podaÊ potrzebnÈ instrukcjÚ. Na przykïad aby
wyĂwietliÊ powitanie w oknie czata, zastosuj poniĝszy kod:
minecraft.Minecraft.create().postToChat("Witamy w labiryntach Minecrafta!")
Przy dïuĝszych instrukcjach taki kod jest nieczytelny, dlatego w przedstawionym
programie utworzyïem zmiennÈ mc, którÈ moĝna stosowaÊ jako skrót polecenia
minecraft.Minecraft.create(). DziÚki temu moĝna przesyïaÊ komunikaty za po-
mocÈ krótszych wierszy kodu, tak jak w przykïadowym programie.
WSKAZÓWKA
JeĂli kod nie dziaïa, zwróÊ uwagÚ na wielkoĂÊ znaków. W Pythonie ma ona znaczenie, dlatego
musisz stosowaÊ maïe i wielkie litery dokïadnie w taki sposób jak w przykïadowym kodzie.
ZwróÊ uwagÚ na notacjÚ wielbïÈdziÈ w nazwie
postToChat
i wielkÈ literÚ
M
w poleceniu
minecraft.Minecraft.create()
.
WspóïrzÚdne w Minecrafcie
Jak ïatwo siÚ domyĂliÊ, kaĝdy punkt w Ăwiecie Minecrafta ma wspóïrzÚdne. Do okre-
Ălenia pozycji punktu potrzebne sÈ wspóïrzÚdne w trzech wymiarach:
P
OĂ x. Jest równolegïa do powierzchni i przyjmuje wartoĂci od –127,7 do 127,7.
P
OĂ y. Jest ustawiona pionowo i okreĂla wysokoĂÊ. Moĝesz wznieĂÊ siÚ aĝ na wy-
sokoĂÊ 500 jednostek, jednak juĝ przy wysokoĂci 70 ziemia nie jest widoczna,
dlatego dalsze wznoszenie siÚ nie ma sensu. Poziom morza to 0. Moĝesz roz-
bijaÊ bloki, aby drÈĝyÊ tunele pod wodÈ. Mnie udaïo siÚ zejĂÊ do poziomu –70
jednostek, zanim wypadïem ze Ăwiata i zginÈïem. Jest to jedyny moĝliwy spo-
sób zabicia postaci w Minecrafcie na Raspberry Pi, jaki udaïo mi siÚ znaleěÊ.
P
OĂ z. Takĝe jest równolegïa do powierzchni i przyjmuje wartoĂci od –127,7 do
127,7.
Celowo podaïem wspóïrzÚdne w tej wïaĂnie kolejnoĂci, poniewaĝ tak sÈ podawane
w Minecrafcie. JeĂli — podobnie jak ja — czÚsto uĝywasz wspóïrzÚdnych x i y do
okreĂlania pozycji w Ăwiecie dwuwymiarowym (na przykïad punktów na ekranie),
bÚdziesz musiaï przyzwyczaiÊ siÚ do tego, ĝe y reprezentuje wysokoĂÊ. W tym roz-
dziale zwykle uĝywam wspóïrzÚdnych x i z do okreĂlania pozycji Ăcian (zmienia siÚ
ona w zaleĝnoĂci od Ăciany), a wspóïrzÚdnej y — do opisywania jej wysokoĂci (jest
ona niezaleĝna od lokalizacji Ăciany).
158
RASPBERRY PI. NAJLEPSZE PROJEKTY
W trakcie poruszania siÚ po planszy w lewym górnym rogu okna Minecrafta zmie-
niajÈ siÚ wspóïrzÚdne gracza. JeĂli spróbujesz wyjĂÊ poza Ăwiat gry, natrafisz na
niewidzialnÈ ĂcianÚ, której nie da siÚ przebiÊ — podobnie jak w filmie Truman
Show, gdzie jednak bohater znalazï drzwi.
Zmienianie pozycji gracza
Za pomocÈ poniĝszego polecenia moĝna przenieĂÊ postaÊ w dowolne miejsce w Ăwie-
cie Minecrafta:
mc.player.setTilePos(x, y, z)
Aby na przykïad zrzuciÊ postaÊ z nieba w Ărodek Ăwiata, uĝyj nastÚpujÈcego wy-
woïania:
mc.player.setTilePos(0, 100, 0)
WSKAZÓWKA
Nie musisz umieszczaÊ tego polecenia w aplikacji i uruchamiaÊ jej. JeĂli juĝ uruchomiïeĂ pro-
gram w celu wïÈczenia moduïu Minecrafta, moĝesz uĝywaÊ powïoki Pythona do wprowa-
dzania instrukcji sïuĝÈcych do przenoszenia postaci i dodawania bloków.
JeĂli nie jest wïÈczony tryb latania, postaÊ spadnie z nieba w Ărodku Ăwiata. Jeĝeli
tryb latania jest aktywny, kliknij okno Minecrafta i dwukrotnie wciĂnij spacjÚ, aby
wyïÈczyÊ ten tryb i rozpoczÈÊ opadanie.
PostaÊ moĝna umieĂciÊ w dowolnym miejscu Ăwiata gry. Czasem oznacza to, ĝe po-
staÊ pojawi siÚ w Ărodku góry lub innej struktury, w której ruch jest niemoĝliwy.
W takiej sytuacji zmieñ pozycjÚ gracza za pomocÈ kodu. Dobrym rozwiÈzaniem jest
zwykle umieszczenie postaci na duĝej wysokoĂci, poniewaĝ moĝna z niej spaĂÊ na
najwyĝej poïoĝony punkt.
Dodawanie bloków
Aby dodaÊ blok do Ăwiata, zastosuj poniĝsze polecenie:
mc.setBlock(x, y, z, blockTypeId)
Parametr blockTypeId to liczba reprezentujÈca materiaï, z jakiego zbudowany jest
dodawany blok. PeïnÈ listÚ materiaïów znajdziesz na stronie http://www.minecraft
´
wiki.net/wiki/Data_values_(Pocket_Edition). Waĝne sÈ liczby z kolumny Dec z ta-
beli z tej strony, poniewaĝ potrzebujesz liczby dziesiÚtnej, a nie szesnastkowej.
Poprawne sÈ wartoĂci z przedziaïu od 0 do 108, a takĝe kilka wiÚkszych liczb.
W tabeli 7.1 opisujÚ wybrane materiaïy, które prawdopodobnie okaĝÈ siÚ najbar-
dziej przydatne w tym projekcie oraz w trakcie wykonywania eksperymentów.
ROZDZIA 7. GENEROWANIE LABIRYNTÓW W MINECRAFCIE
159
Tabela 7.1. Materiaïy z gry Minecraft: Pi Edition
blockTypeId
Typ bloku
0
Powietrze
1
Kamieñ
2
Trawa
3
Bïoto
5
Deska
8
Woda
10
Lawa
12
Piasek
20
Szklana cegïa
24
Piaskowiec
41
Zïota cegïa
45
Cegïa
47
Póïka na ksiÈĝki
53
Drewniane schody
57
Diamentowy blok
64
Drewniane drzwi
81
Kaktus
WSKAZÓWKA
Gdy uĝywasz bloków wody lub lawy, moĝesz wywoïaÊ powódě. Dlatego na potrzeby ekspe-
rymentów utwórz nowy Ăwiat.
DostÚpne jest teĝ inne polecenie, które pozwala tworzyÊ duĝe prostopadïoĂciany
z bloków okreĂlonego typu. Aby zastosowaÊ to polecenie, podaj wspóïrzÚdne dwóch
przeciwlegïych naroĝników oraz materiaï, z którego bryïa ma byÊ zbudowana:
mc.setBlocks(x1, y1, z1, x2, y2, z2, blockTypeId)
Aby szybko zbudowaÊ ceglany schron, utwórz duĝy prostopadïoĂcian z cegïy, a na-
stÚpnie umieĂÊ w nim prostopadïoĂcian z powietrza. Powietrze zastÚpuje dowolne
inne bloki, co powoduje ich usuniÚcie ze Ăwiata. Oto przykïad:
mc.setBlocks(0, 0, 0, 10, 5, 7, 45) # Cegáa
mc.setBlocks(1, 0, 1, 9, 5, 6, 0) # Powietrze
Ten kod w punkcie o wspóïrzÚdnych (0, 0, 0) tworzy schron o powierzchni 10 × 7
bloków i wysokoĂci 5 bloków. ¥ciany majÈ gruboĂÊ jednego bloku, poniewaĝ obszar od
pierwszego do dziewiÈtego bloku na osi x, od pierwszego do szóstego bloku na osi z i od
zerowego do piÈtego bloku na osi y sÈ wypeïniane powietrzem. Po wszystkich stro-
nach pozostaje wiÚc jedna Ăciana o gruboĂci jednego bloku, a góra budowli jest odkryta.
160
RASPBERRY PI. NAJLEPSZE PROJEKTY
WSKAZÓWKA
PamiÚtaj, ĝe symbol
#
reprezentuje komentarz dla programisty. Komputer ignoruje zawartoĂÊ
wiersza znajdujÈcÈ siÚ po tym symbolu.
ChoÊ przy okreĂlaniu pozycji postaci moĝna posïugiwaÊ siÚ wspóïrzÚdnymi z czÚ-
Ăciami uïamkowymi (na przykïad 1,7), to przy dodawaniu bloków wspóïrzÚdne sÈ
zaokrÈglane do najbliĝszej liczby caïkowitej.
Uniemoĝliwianie graczom modyfikowania Ăwiata
Wiem, ĝe nigdy byĂ nie oszukiwaï w grze, jednak szukanie drogi w labiryncie, w któ-
rym moĝna przypadkowo wyrÈbaÊ sobie przejĂcie, nie byïoby ciekawe, prawda? Aby
uniemoĝliwiÊ graczom usuwanie lub dodawanie bloków w Ăwiecie, zastosuj nastÚ-
pujÈcy wiersz:
mc.setting("world.immutable",True)
Sïowo immutable jest czÚsto stosowane w kontekĂcie programowania i oznacza
„niezmienny”.
Ustawianie parametrów labiryntu
Skoro wiesz juĝ, jak dodawaÊ bloki i uĝywaÊ bloków z powietrzem do opróĝniania
przestrzeni, moĝesz przystÈpiÊ do pisania programu generujÈcego labirynty. W tym
programie wykorzystasz zestaw staïych przeznaczonych na waĝne informacje o labi-
ryncie. Staïe to rodzaj zmiennych, których wartoĂci zdecydowaïeĂ siÚ nie zmieniaÊ
w trakcie dziaïania programu. Nazwy staïych zwykle zapisuje siÚ wielkimi literami,
aby zasygnalizowaÊ ich przeznaczenie dla osób czytajÈcych kod programu i uïatwiÊ
samemu sobie pamiÚtanie o tym, ĝe program nie powinien zmieniaÊ wartoĂci tych
elementów. ZastÈpienie w programie liczb staïymi pozwala w przyszïoĂci ïatwiej
wprowadzaÊ zmiany, a takĝe znacznie poprawia czytelnoĂÊ kodu i pomaga zro-
zumieÊ, co reprezentujÈ poszczególne wartoĂci.
WSKAZÓWKA
W nazwach zmiennych wielkoĂÊ liter ma znaczenie, dlatego dla Pythona
SIZE
i
size
to dwie
róĝne zmienne (jednak stosowanie obu tych nazw w jednym programie nie jest najlepszym
pomysïem).
Program najpierw ustawia staïe:
SIZE = 10
HEIGHT = 2
MAZE_X = 0
GROUND = 0
MAZE_Z = 0
MAZE_MATERIAL = 1 # KamieĔ
GROUND_MATERIAL = 2 # Trawa
CEILING = False
ROZDZIA 7. GENEROWANIE LABIRYNTÓW W MINECRAFCIE
161
Budowanie labiryntu zaczniesz od siatki Ăcian z jednoblokowymi przestrzeniami
(komórkami) miÚdzy nimi. Efekt wyglÈdem przypomina gofry (rysunek 7.2). Kaĝda
komórka ma poczÈtkowo cztery Ăciany, a program usuwa je, dziÚki czemu powstajÈ
Ăcieĝki miÚdzy komórkami, a ostatecznie — labirynt. Tu jest on kwadratowy, a pa-
rametr SIZE okreĂla jego wielkoĂÊ w komórkach. Labirynt z parametrem SIZE rów-
nym 10 ma po 10 komórek w wymiarach x i z, jednak w Ăwiecie Minecrafta zajmuje
dwukrotnie wiÚcej miejsca (20 na 20 bloków), poniewaĝ miÚdzy komórkami znaj-
dujÈ siÚ jednoblokowe Ăciany. Stanie siÚ to zrozumiaïe, gdy zaczniesz budowaÊ la-
birynt. Próbowaïem tworzyÊ labirynty o parametrze SIZE równym 40, jednak ich bu-
dowanie zajmuje wiele czasu, a eksploracja — caïe wieki. Na razie wystarczy wartoĂÊ
10. JeĂli w Ăwiecie nie ma wystarczajÈco duĝo miejsca na labirynt, program zakoñczy
pracÚ i zgïosi bïÈd.
Rysunek 7.2.
PoczÈtkowa
siatka
Parametr HEIGHT okreĂla w blokach wysokoĂÊ Ăcian labiryntu. Wybraïem wartoĂÊ 2,
poniewaĝ przy wartoĂci 1 moĝna przeskakiwaÊ Ăciany labiryntu (gracz automatycz-
nie wchodzi na bloki o tej wysokoĂci). Wyĝsze wartoĂci powodujÈ, ĝe nie moĝna
zobaczyÊ widocznych w oddali gór, które sÈ dla uĝytkownika cennÈ wskazówkÈ
wizualnÈ.
162
RASPBERRY PI. NAJLEPSZE PROJEKTY
Staïe MAZE_X, GROUND i MAZE_Z okreĂlajÈ wspóïrzÚdne poczÈtku labiryntu. Materiaï,
z którego zbudowany jest labirynt (MAZE_MATERIAL), to kamieñ (1), a materiaïem podïo-
ĝa (GROUND_MATERIAL) jest trawa (2). DostÚpna jest teĝ opcja, która pozwala dodaÊ sufit,
co uniemoĝliwia graczowi wzniesienie siÚ ponad labirynt. Na razie jednak opcja ta jest
wyïÈczona, co pozwala swobodnie eksplorowaÊ labirynt w trakcie jego tworzenia.
WSKAZÓWKA
Doskonale wyglÈda labirynt z póïek z ksiÈĝkami (
MAZE_MATERIAL=47
).
Przygotowywanie podïoĝa
JednÈ z pierwszych rzeczy, jakie trzeba zrobiÊ, jest upewnienie siÚ, ĝe labirynt
znajduje siÚ na równym staïym lÈdzie. Poniewaĝ Ăwiat Minecrafta jest generowany
dynamicznie, moĝe siÚ okazaÊ, ĝe stawiasz budowlÚ w Ărodku góry lub na morzu.
Oprócz powierzchni przeznaczonej na labirynt naleĝy oczyĂciÊ obszar 10 bloków
wokóï budowli, aby gracz mógï wygodnie siÚ do niej zbliĝyÊ i obejĂÊ jÈ dookoïa.
Najpierw opróĝnij obszar przez wypeïnienie go blokami powietrza. Spowoduje to
usuniÚcie wszystkich innych obiektów z danego miejsca.
Labirynt zajmuje mierzony w blokach obszar od MAZE_X do MAZE_X+(SIZE*2) i od
MAZE_Z do MAZE_Z+(SIZE*2). Liczba bloków jest dwa razy wiÚksza od liczby komórek
(SIZE), poniewaĝ na prawo i poniĝej kaĝdej komórki znajduje siÚ Ăciana. ¥rodkowy
punkt labiryntu w Ăwiecie Minecrafta ma wspóïrzÚdne MAZE_X+SIZE, MAZE_Z+SIZE.
Trzeba teĝ opróĝniÊ obszar 10 bloków w kaĝdym kierunku od labiryntu. Poniĝszy
kod usuwa wszystkie bloki na wysokoĂÊ 150 bloków od poziomu labiryntu. DziÚki
temu nie istnieje ryzyko, ĝe nieusuniÚte bloki góry spadnÈ z nieba do labiryntu
i bÚdÈ leĝeÊ w korytarzach:
mc.setBlocks(MAZE_X-10, GROUND, MAZE_Z-10, MAZE_X+(SIZE*2)+10, GROUND+150,
´MAZE_Z+(SIZE*2)+10, 0)
mc.setBlocks(MAZE_X-10, GROUND, MAZE_Z-10, MAZE_X+(SIZE*2)+10, GROUND,
´MAZE_Z+(SIZE*2)+10, GROUND_MATERIAL)
Zalecam, aby dodaÊ blok wyznaczajÈcy poczÈtkowy róg labiryntu (wspóïrzÚdne
MAZE_X, MAZE_Z). Jest to przydatne przy pisaniu i debugowaniu programu, poniewaĝ
pozwala okreĂliÊ poïoĝenie labiryntu przy obserwowaniu go z lotu ptaka. Blok
moĝna dodaÊ za pomocÈ poniĝszego kodu:
mc.setBlock(MAZE_X, GROUND+HEIGHT+1, MAZE_Z, MAZE_MATERIAL)
UmieĂÊ postaÊ nad Ărodkiem labiryntu, abyĂ mógï patrzeÊ w dóï i obserwowaÊ jego
powstawanie. JeĂli nie masz wïÈczonego trybu latania, spadniesz na ĂcianÚ labi-
ryntu, jednak zawsze moĝesz ponownie uruchomiÊ ten tryb.
mc.player.setTilePos(MAZE_X+SIZE, GROUND+25, MAZE_Z+SIZE)
ROZDZIA 7. GENEROWANIE LABIRYNTÓW W MINECRAFCIE
163
Dodawanie Ăcian labiryntu
Aby utworzyÊ przypominajÈcÈ gofra siatkÚ, zastosuj poniĝszy kod:
for line in range(0, (SIZE+1)*2, 2):
mc.setBlocks(MAZE_X+line, GROUND+1, MAZE_Z, MAZE_X+line, GROUND+HEIGHT,
´MAZE_Z+(SIZE*2), MAZE_MATERIAL)
mc.setBlocks(MAZE_X, GROUND+1, MAZE_Z+line, MAZE_X+(SIZE*2), GROUND+HEIGHT,
´MAZE_Z+line, MAZE_MATERIAL)
PÚtla for przypisuje do zmiennej line liczby parzyste od 0 do SIZE*2. Przed podwo-
jeniem wartoĂci trzeba dodaÊ do SIZE liczbÚ 1, poniewaĝ funkcja range nie zwraca
ostatniej wartoĂci w sekwencji (na przykïad wywoïanie range(1, 10) zwraca licz-
by od 1 do 9). Liczba 2 na koñcu wywoïania range oznacza wielkoĂÊ kroku, tak wiÚc
pÚtla w kaĝdym powtórzeniu przyjmuje kolejne wartoĂci parzyste. W efekcie miÚ-
dzy Ăcianami pozostajÈ puste miejsca (komórki). Przy kaĝdym powtórzeniu pÚtli
uĝywany jest prostopadïoĂcian do narysowania dwóch Ăcian, które biegnÈ przez
caïÈ szerokoĂÊ labiryntu wzdïuĝ osi x i z. To, ĝe w miejscach przeciÚcia siÚ Ăcian
blok jest dodawany dwukrotnie, nie ma znaczenia. ¥ciana jest budowana od pozio-
mu GROUND+1, dlatego gdy usuniesz Ăciany w celu utworzenia Ăcieĝek, nadal bÚdzie
widoczna trawa.
WSKAZÓWKA
Nie zapomnij o dwukropku po instrukcji
for
. Ponadto dwa nastÚpne wiersze muszÈ byÊ wy-
róĝnione wciÚciem (jest to dla Pythona informacja, ĝe naleĝÈ do pÚtli).
PowinieneĂ uzyskaÊ siatkÚ wyglÈdajÈcÈ tak, jak na rysunku 7.3.
Rysunek 7.3.
Siatka
w Minecrafcie
164
RASPBERRY PI. NAJLEPSZE PROJEKTY
Algorytm generowania labiryntu
Przed rozpoczÚciem analizowania kodu, który przeksztaïca gofra w labirynt, wyjaĂniam,
jak ten kod dziaïa. Celem jest utworzenie labiryntu doskonaïego (w sensie technicznym
— nie sÈ to moje przechwaïki). Oznacza to, ĝe w labiryncie ma nie byÊ ĝadnych pÚtli ani
niedostÚpnych miejsc. MiÚdzy dowolnymi dwoma punktami istnieje tylko jedna Ăcieĝka.
Program dziaïa w nastÚpujÈcy sposób:
1.
Punktem wyjĂcia jest utworzony gofr, w którym kaĝda komórka jest otoczona
z czterech stron Ăcianami.
2.
Naleĝy losowo wybraÊ poczÈtkowÈ komórkÚ labiryntu.
3.
Trzeba zbadaÊ wszystkie sÈsiednie komórki i utworzyÊ listÚ tych, które majÈ
wszystkie cztery Ăciany. SÈ to komórki, które nie zostaïy jeszcze odwiedzone.
4.
JeĂli istniejÈ nieodwiedzone sÈsiednie komórki, naleĝy losowo wybraÊ jednÈ
z nich, usunÈÊ ĂcianÚ miÚdzy bieĝÈcÈ i wybranÈ komórkÈ, a nastÚpnie przejĂÊ
do tej ostatniej. W tym momencie to ona staje siÚ bieĝÈcÈ komórkÈ.
5.
Jeĝeli wszystkie komórki sÈsiadujÈce z bieĝÈcÈ zostaïy juĝ odwiedzone, naleĝy
cofnÈÊ siÚ o jednÈ komórkÚ i ustawiÊ jÈ jako bieĝÈcÈ.
6.
Trzeba powtarzaÊ kroki od 3. do 5. do momentu odwiedzenia wszystkich komórek.
Konfigurowanie zmiennych i list
Aby zaimplementowaÊ ten algorytm, naleĝy zastosowaÊ nastÚpujÈce zmienne:
P
Zmienna numberOfCells. Przechowuje ïÈcznÈ liczbÚ komórek labiryntu (czyli
SIZE*SIZE).
P
Zmienna numberOfVisitedCells. Przechowuje liczbÚ komórek odwiedzonych
do tej pory. JeĂli ta liczba jest identyczna z wartoĂciÈ zmiennej numberOfCells,
oznacza to, ĝe algorytm odwiedziï kaĝdÈ komórkÚ i usunÈï jednÈ z jej Ăcian.
Moĝna wiÚc dotrzeÊ do kaĝdej komórki i labirynt jest ukoñczony.
P
Zmienna xposition. ZapamiÚtuje pozycjÚ na wymiarze „
x”
w czasie poruszania
siÚ po labiryncie i generowania go. Pozycja jest mierzona w komórkach i po-
czÈtkowo przyjmuje losowÈ wartoĂÊ z przedziaïu od 1 do SIZE.
P
Zmienna zposition. ZapamiÚtuje pozycjÚ na wymiarze „
z”
w czasie poruszania
siÚ po labiryncie i generowania go. Pozycja jest mierzona w komórkach i po-
czÈtkowo przyjmuje wartoĂÊ losowÈ.
P
Lista
cellsVisitedList[]. Przechowuje ĂcieĝkÚ, dziÚki czemu program moĝe
siÚ cofaÊ. Przy tworzeniu listy naleĝy zapisaÊ w niej poczÈtkowÈ pozycjÚ za
pomocÈ metody append().
P
Zmienne playerx i playerz. SïuĝÈ do zapamiÚtywania poczÈtkowej pozycji,
dziÚki czemu moĝna umieĂciÊ w niej gracza po zbudowaniu labiryntu.
ROZDZIA 7. GENEROWANIE LABIRYNTÓW W MINECRAFCIE
165
W kodzie algorytmów tego rodzaju (jest to algorytm generowania labiryntów
metodÈ DSF) czÚsto potrzebna jest lista lub podobna struktura danych do przecho-
wywania lokalizacji Ăcian. Tutaj jest to niepotrzebne, poniewaĝ w Minecrafcie ist-
niejÈ widoczne Ăciany. JeĂli chcesz, moĝesz zapisaÊ labirynt w Ăwiecie gry.
Poniĝszy kod ustawia poczÈtkowe wartoĂci zmiennych:
numberOfCells = SIZE*SIZE
numberOfVisitedCells = 1
cellsVisitedList = []
xposition = random.randint(1, SIZE)
zposition = random.randint(1, SIZE)
playerx = xposition
playerz = zposition
cellsVisitedList.append((xposition, zposition))
Tworzenie funkcji
W programie potrzebnych jest kilka podstawowych funkcji. Oto one:
P
Funkcje realx(x) i realz(z). PrzeksztaïcajÈ wspóïrzÚdne labiryntu (podawane
w komórkach) na wspóïrzÚdne Ăwiata Minecrafta (mierzone w blokach i prze-
suniÚte wzglÚdem poczÈtkowej pozycji labiryntu).
P
Funkcje showMaker(x,z) i hideMaker(x,z). DodajÈ i ukrywajÈ zïoty blok poka-
zujÈcy, do której komórki program doszedï w trakcie budowania labiryntu.
Ciekawe jest obserwowanie zmian tych komórek z lotu ptaka, a ponadto funk-
cje te sÈ przydatne w trakcie tworzenia i debugowania programu.
P
Funkcja demolish(realx,realz). Sïuĝy do usuwania Ăcian w labiryncie. Jako
parametry przyjmuje rzeczywiste wspóïrzÚdne ze Ăwiata Minecrafta.
P
Funkcja testAllWalls(cellx, cellz). Sprawdza, czy wszystkie cztery Ăciany ko-
mórki pozostaïy nietkniÚte. JeĂli tak jest, zwraca wartoĂÊ True (w przeciwnym
razie zwraca False). W tej funkcji uĝywane jest polecenie mc.getBlock(x, y, z),
które okreĂla typ bloku (blockTypeId) stojÈcego w danym miejscu. W standar-
dowy sposób (za pomocÈ dwóch znaków równoĂci) naleĝy sprawdziÊ, czy ten
typ jest taki sam jak typ materiaïu Ăcian (MAZE_MATERIAL). JeĂli tak jest, oznacza
to, ĝe w danym miejscu stoi Ăciana.
Dodaj poniĝsze definicje funkcji w poczÈtkowej czÚĂci programu, po instrukcji usta-
wiajÈcej moduï Minecrafta:
def realx(x):
return MAZE_X+(x*2)-1
def realz(z):
return MAZE_Z+(z*2)-1
def showMaker(x, z):
mc.setBlock(realx(x), GROUND+1, realz(z), 41) # 41=záoto
166
RASPBERRY PI. NAJLEPSZE PROJEKTY
def hideMaker(x, z):
mc.setBlock(realx(x), GROUND+1, realz(z), 0)
def demolish(realx, realz):
mc.setBlocks(realx, GROUND+1, realz, realx, HEIGHT+GROUND, realz, 0)
def testAllWalls(cellx, cellz):
if mc.getBlock(realx(cellx)+1, GROUND+1, realz(cellz))==MAZE_MATERIAL
´and mc.getBlock(realx(cellx)-1, GROUND+1, realz(cellz))==MAZE_MATERIAL
´and mc.getBlock(realx(cellx), GROUND+1, realz(cellz)+1)==MAZE_MATERIAL
´and mc.getBlock(realx(cellx), GROUND+1, realz(cellz)-1)==MAZE_MATERIAL:
return True
else:
return False
WSKAZÓWKA
JeĂli wystÈpiï bïÈd, sprawdě, czy nie brakuje dwukropków po instrukcjach
def
i
if
.
Tworzenie gïównej pÚtli
Algorytm tworzÈcy labirynt dziaïa do momentu odwiedzenia wszystkich komórek.
Dlatego rozpoczyna siÚ od poniĝszej instrukcji:
while numberOfVisitedCells < numberOfCells:
Trzeba sprawdziÊ, czy Ăciany w komórkach sÈsiadujÈcych z bieĝÈcÈ pozostajÈ
nietkniÚte. W tym celu naleĝy zbadaÊ po kolei kaĝdy kierunek za pomocÈ funkcji
testAllWalls(x, z). Po znalezieniu komórki z wszystkimi Ăcianami naleĝy za po-
mocÈ metody append() dodaÊ jej kierunek do listy possibleDirections[]. Tak wy-
glÈda implementacja trzeciego kroku algorytmu (pamiÚtaj, ĝe caïy poniĝszy kod jest
wciÚty wzglÚdem nadrzÚdnej instrukcji while):
possibleDirections = []
if testAllWalls(xposition-1, zposition):
possibleDirections.append("left")
if testAllWalls(xposition+1, zposition):
possibleDirections.append("right")
if testAllWalls(xposition, zposition-1):
possibleDirections.append("up")
if testAllWalls(xposition, zposition+1):
possibleDirections.append("down")
OkreĂlenia up, down, left i right (czyli góra, dóï, lewa, prawa) sÈ w trójwymiarowym
Ăwiecie doĂÊ nieprecyzyjne. Zastosowaïem je, poniewaĝ sÈ ïatwe do zrozumienia.
JeĂli w trakcie generowania labiryntu spojrzysz na niego z lotu ptaka i ustawisz siÚ
tak, aby poczÈtkowy naroĝnik labiryntu (o wspóïrzÚdnych MAZE_X, MAZE_Z) znajdo-
waï siÚ w lewym górnym rogu, wymienione wyĝej okreĂlenia bÚdÈ wskazywaïy
wïaĂciwe kierunki.
ROZDZIA 7. GENEROWANIE LABIRYNTÓW W MINECRAFCIE
167
Moĝe zauwaĝyïeĂ, ĝe kod nie sprawdza, czy komórki znajdujÈ siÚ na krawÚdziach
labiryntu. Co siÚ stanie przy sprawdzaniu komórek, które wychodzÈ poza lewÈ lub
dolnÈ krawÚdě labiryntu? Nie stanowi to problemu. Kod programu automatycznie
zatrzymuje siÚ przed krawÚdziami. Poniewaĝ sprawdzane „komórki” poza krawÚ-
dziÈ nie majÈ wszystkich czterech Ăcian (ich jedynÈ ĂcianÈ jest bok labiryntu), tak
wiÚc algorytm nigdy do nich nie przechodzi.
W kroku czwartym algorytm losowo wybiera jednÈ z nieodwiedzonych sÈsiadujÈ-
cych komórek. Usuwa ĂcianÚ miÚdzy bieĝÈcÈ i wybranÈ komórkÈ, po czym prze-
chodzi do tej ostatniej. Aby ustaliÊ, czy istnieje choÊ jeden nieodwiedzony sÈsiad,
naleĝy sprawdziÊ dïugoĂÊ listy possibleDirections. JeĂli jest ona róĝna od 0 (!=0),
naleĝy wykonaÊ odpowiednie operacje. Caïy omawiany fragment powinien byÊ wy-
róĝniony wciÚciem wzglÚdem nadrzÚdnej pÚtli while. JeĂli masz trudnoĂci z usta-
leniem wïaĂciwego poziomu wciÚcia, zapoznaj siÚ z peïnym kodem z listingu 7.1
zamieszczonego w koñcowej czÚĂci rozdziaïu.
Przed zmianÈ pozycji naleĝy ukryÊ zïotÈ cegïÚ wskazujÈcÈ pozycjÚ w labiryncie:
hideMaker(xposition, zposition)
if len(possibleDirections)!=0:
directionChosen=random.choice(possibleDirections)
if directionChosen=="left":
demolish(realx(xposition)-1, realz(zposition))
xposition -= 1
if directionChosen=="right":
demolish(realx(xposition)+1, realz(zposition))
xposition += 1
if directionChosen=="up":
demolish(realx(xposition), realz(zposition)-1)
zposition -= 1
if directionChosen=="down":
demolish(realx(xposition), realz(zposition)+1)
zposition += 1
Po przejĂciu do nowej komórki trzeba zwiÚkszyÊ liczbÚ odwiedzonych komórek
o jeden i dodaÊ nowÈ komórkÚ do listy przechowujÈcej ĂcieĝkÚ. Jest to takĝe dobry
moment na wyĂwietlenie w komórce zïotego bloku pokazujÈcego proces budowania
labiryntu:
numberOfVisitedCells += 1
cellsVisitedList.append((xposition, zposition))
showMaker(xposition, zposition)
Warto wyjaĂniÊ sposób przechowywania listy odwiedzonych komórek. Zmienne
xposition i zposition znajdujÈ siÚ w nawiasach oznaczajÈcych krotkÚ. Krotka to
sekwencja danych. Przypomina ona nieco listÚ, jednak róĝni siÚ tym, ĝe nie umoĝ-
liwia modyfikowania wartoĂci (jest niezmienna). Tak wiÚc cellsVisitedList to lista
168
RASPBERRY PI. NAJLEPSZE PROJEKTY
z krotkami, które zawierajÈ pary wspóïrzÚdnych x i z. Do sprawdzenia zawartoĂci
listy moĝna wykorzystaÊ powïokÚ Pythona. Oto przykïad wziÚty z jednego z prze-
biegów programu. WidaÊ tu ĂcieĝkÚ przejĂcia przez labirynt:
>>> print cellsVisitedList
[(6, 6,), (6, 7), (6, 8), (5, 8), (4, 8), (3, 8), (3, 7)]
JeĂli dana komórka nie ma nieodwiedzonych sÈsiadów, w piÈtym kroku algorytmu
naleĝy wróciÊ do wczeĂniejszej pozycji na Ăcieĝce. Wymaga to pobrania ostatniego
elementu z listy ze ĂcieĝkÈ. Zadanie to moĝna wykonaÊ za pomocÈ metody pop()
przeznaczonej dla list. Metoda ta pobiera ostatni element z listy i usuwa go z niej.
W programie element ten jest przypisywany do zmiennej retrace, która zapisuje
krotkÚ ze wspóïrzÚdnymi x i z pozycji w labiryncie. Do wskazywania poszczegól-
nych wartoĂci krotki (podobnie jak w przypadku listy) sïuĝy indeks. Indeksowanie
rozpoczyna siÚ od zera, dlatego wywoïanie retrace[0] zwraca wspóïrzÚdnÈ x po-
przedniej komórki, a wywoïanie retrace[1] zwraca wspóïrzÚdnÈ z. Oto potrzebny
kod (obejmuje teĝ wiersz wyĂwietlajÈcy zïoty blok w poprzedniej komórce):
else: # Ten kod naleĪy wywoáaü, jeĞli nie istnieją nieodwiedzone sąsiednie komórki
retrace = cellsVisitedList.pop()
xposition = retrace[0]
zposition = retrace[1]
showMaker(xposition, zposition)
Warto zauwaĝyÊ, ĝe ta instrukcja else powinna byÊ wyrównana wzglÚdem powiÈ-
zanej instrukcji if (sprawdzajÈcej, czy moĝna przejĂÊ dalej w jednym z kierunków).
Krok szósty algorytmu zostaï juĝ zaimplementowany, poniewaĝ pÚtla while po od-
wiedzeniu kaĝdej komórki powtarza wyróĝniony wciÚciem kod.
Dodawanie sufitu
OsobiĂcie uwaĝam, ĝe wiÚcej zabawy daje rezygnacja z sufitu. DziÚki temu moĝna
siÚ wznieĂÊ, podziwiaÊ labirynt i spaĂÊ w jego dowolne miejsce. JeĂli jednak chcesz
zbudowaÊ opartÈ na labiryncie grÚ i uniemoĝliwiÊ uĝytkownikom oszukiwanie, dodaj
sufit za pomocÈ poniĝszego kodu. Naleĝy teĝ zmieniÊ wartoĂÊ zmiennej CEILING
w poczÈtkowej czÚĂci programu na True. Tu sufit budowany jest ze szklanych bloków,
dziÚki czemu w korytarzach nie jest ciemno:
if CEILING == True:
mc.setBlocks(MAZE_X, GROUND+HEIGHT+1, MAZE_Z, MAZE_X+(SIZE*2),
´
GROUND+HEIGHT+1, MAZE_Z+(SIZE*2), 20)
OkreĂlanie pozycji gracza
W ostatnim kroku naleĝy umieĂciÊ gracza w losowym miejscu, od którego program
rozpoczÈï generowanie labiryntu. Moĝesz umieĂciÊ postaÊ w dowolnym miejscu,
jednak to jest równie dobre jak kaĝde inne i pozwala wykorzystaÊ wygenerowane
wczeĂniej losowe wspóïrzÚdne:
mc.player.setTilePos(realx(playerx), GROUND+1, realz(playerz))
ROZDZIA 7. GENEROWANIE LABIRYNTÓW W MINECRAFCIE
169
Teraz moĝesz rozpoczÈÊ grÚ! Rysunek 7.4 przedstawia labirynt od Ărodka.
Rysunek 7.4.
Znajdowanie
drogi
w labiryncie
Ostateczna wersja kodu
Listing 7.1 przedstawia gotowy i kompletny kod.
Listing 7.1. Generowanie labiryntów do gry Minecraft
#!/usr/bin/env python
"""
Minecraft Maze Maker
Autor: Sean McManus
Z ksiąĪki Raspberry Pi. Najlepsze projekty
"""
import sys, random
sys.path.append("./mcpi/api/python/mcpi")
import minecraft
mc = minecraft.Minecraft.create()
mc.postToChat("Witamy w generatorze labiryntów do Minecrafta!")
def realx(x):
return MAZE_X+(x*2)-1
def realz(z):
return MAZE_Z+(z*2)-1
def showMaker(x, z):
mc.setBlock(realx(x), GROUND+1, realz(z), 41) # 41=záoto
def hideMaker(x, z):
170
RASPBERRY PI. NAJLEPSZE PROJEKTY
mc.setBlock(realx(x), GROUND+1, realz(z), 0)
def demolish(realx, realz):
mc.setBlocks(realx, GROUND+1, realz, realx, HEIGHT+GROUND, realz, 0)
def testAllWalls(cellx, cellz):
if mc.getBlock(realx(cellx)+1, GROUND+1, realz(cellz))==MAZE_MATERIAL
´and mc.getBlock(realx(cellx)-1, GROUND+1, realz(cellz))==MAZE_MATERIAL
´and mc.getBlock(realx(cellx), GROUND+1, realz(cellz)+1)==MAZE_MATERIAL
´and mc.getBlock(realx(cellx), GROUND+1, realz(cellz)-1)==MAZE_MATERIAL:
return True
else:
return False
mc.setting("world_immutable", True)
# Konfigurowanie labiryntu
SIZE = 10
HEIGHT = 2
MAZE_X = 0
GROUND = 0
MAZE_Z = 0
MAZE_MATERIAL = 1 # 1=kamieĔ
GROUND_MATERIAL = 2 # 2=trawa
CEILING = False
mc.setBlocks(MAZE_X-10, GROUND, MAZE_Z-10, MAZE_X+(SIZE*2)+10, GROUND+150,
´MAZE_Z+(SIZE*2)+10, 0) # powietrze
mc.setBlocks(MAZE_X-10, GROUND, MAZE_Z-10, MAZE_X+(SIZE*2)+10, GROUND,
´MAZE_Z+(SIZE*2)+10, GROUND_MATERIAL)
# Przygotowywanie podáoĪa
mc.setBlock(MAZE_X, GROUND+HEIGHT+1, MAZE_Z, MAZE_MATERIAL)
# Znacznik początku labiryntu
mc.player.setTilePos(MAZE_X+SIZE, GROUND+25, MAZE_Z+SIZE)
# Przenoszenie gracza nad Ğrodek labiryntu
mc.postToChat("Trwa budowanie labiryntu...")
# Tworzenie siatki ze Ğcianami
for line in range(0, (SIZE+1)*2, 2):
mc.setBlocks(MAZE_X+line, GROUND+1, MAZE_Z, MAZE_X+line, GROUND+HEIGHT,
´MAZE_Z+(SIZE*2), MAZE_MATERIAL)
mc.setBlocks(MAZE_X, GROUND+1, MAZE_Z+line, MAZE_X+(SIZE*2), GROUND+HEIGHT,
´MAZE_Z+line, MAZE_MATERIAL)
# Konfigurowanie zmiennych uĪywanych przy tworzeniu labiryntu
numberOfCells = SIZE*SIZE
numberOfVisitedCells = 1 # Jeden odpowiada początkowej komórce
cellsVisitedList = []
xposition = random.randint(1, SIZE)
zposition = random.randint(1, SIZE)
playerx = xposition
playerz = zposition
showMaker(xposition, zposition)
ROZDZIA 7. GENEROWANIE LABIRYNTÓW W MINECRAFCIE
171
cellsVisitedList.append((xposition, zposition))
while numberOfVisitedCells < numberOfCells:
possibleDirections = []
if testAllWalls(xposition-1, zposition):
possibleDirections.append("left")
if testAllWalls(xposition+1, zposition):
possibleDirections.append("right")
if testAllWalls(xposition, zposition-1):
possibleDirections.append("up")
if testAllWalls(xposition, zposition+1):
possibleDirections.append("down")
hideMaker(xposition, zposition)
if len(possibleDirections)!=0:
directionChosen=random.choice(possibleDirections)
# Usuwanie Ğciany w wybranym kierunku
if directionChosen=="left":
demolish(realx(xposition)-1, realz(zposition))
xposition -= 1
if directionChosen=="right":
demolish(realx(xposition)+1, realz(zposition))
xposition += 1
if directionChosen=="up":
demolish(realx(xposition), realz(zposition)-1)
zposition -= 1
if directionChosen=="down":
demolish(realx(xposition), realz(zposition)+1)
zposition += 1
numberOfVisitedCells += 1
cellsVisitedList.append((xposition, zposition))
showMaker(xposition, zposition)
else: # Ten kod naleĪy wykonaü, jeĞli nie istnieją nieodwiedzone sąsiednie komórki
retrace = cellsVisitedList.pop()
xposition = retrace[0]
zposition = retrace[1]
showMaker(xposition, zposition)
if CEILING == True:
mc.setBlocks(MAZE_X, GROUND+HEIGHT+1, MAZE_Z, MAZE_X+(SIZE*2),
´GROUND+HEIGHT+1, MAZE_Z+(SIZE*2), 20)
mc.postToChat("Labirynt jest gotowy!")
mc.postToChat("Udanego eksplorowania!")
mc.player.setTilePos(realx(playerx), GROUND+1, realz(playerz))
172
RASPBERRY PI. NAJLEPSZE PROJEKTY
Twoja kolej
Po zbudowaniu labiryntu zïota cegïa pozostaje widoczna, dlatego moĝesz spróbowaÊ
jÈ znaleěÊ. Moĝesz teĝ dodaÊ inne obiekty do znalezienia w labiryncie i okreĂliÊ czas
na dotarcie do nich. Polecenie mc.player.getTilePos() sprawdza, w którym miejscu
Ăwiata Minecrafta znajduje siÚ gracz, i zwraca wynik w postaci wspóïrzÚdnych x, y i z.
Kod do tworzenia zegarów znajdziesz w rozdziale 9., „Sprawdě swój czas reakcji”.
Moĝesz dodaÊ wejĂcie i wyjĂcie w losowych punktach bocznej Ăciany labiryntu,
a nastÚpnie jako cel postawiÊ przejĂcie z wejĂcia do wyjĂcia. Aby uïatwiÊ przecho-
dzenie duĝych labiryntów, dodaj punkty orientacyjne; wykorzystaj róĝne materiaïy
lub postaw bloki na niektórych Ăcianach. Po wygenerowaniu labiryntu moĝna usu-
nÈÊ losowe Ăciany, aby utworzyÊ skróty. Inna moĝliwoĂÊ to zastÈpienie wybranych
Ăcian szklanymi blokami, co pozwoli zaglÈdaÊ w inne korytarze. A co powiesz na
wielopoziomowy labirynt ze schodami miÚdzy poziomami? MoĝliwoĂci sÈ naprawdÚ
niesamowite.
Skorowidz
A
Abrams Laurence, 82
adapter
DVI, 33
HDMI, 33
HDMI/VGA, 33
pasywny, 33
Pi-View, 33
adres IP, 291, 294, 295
alarm, 264, 284
Alcorn Allan, 102
algorytm
generowania labiryntów
metodÈ DSF, 165
rekurencyjny, 80
analiza danych, Patrz: dane
analiza
Android, 24, 25
aplikacja, Patrz: program
Arch, 24
archiwum tar, 231
Arduino, 361, 368
programowanie, 372, 377,
381
arkusz kalkulacyjny
Calc, 420
Excel, 420
atak
przez odtwarzanie, 275
przez przepeïnienie
bufora, 265
sïownikowy, 296
automat skoñczony, Patrz:
maszyna stanowa
automatyzowanie
domu, 284, 290
B
Baer Ralph, 102
bajt, 246
barwa, Patrz teĝ: kolor
addytywna, 179
subtraktywna, 180
baza danych, 196
bezpieczeñstwo, 265
atak
przez odtwarzanie, 275
przez przepeïnienie
bufora, 265
sïownikowy, 296
biblioteka, Patrz teĝ: pakiet
Pygame, 84, 87, 105
Twittera, 220
bit, 246
bit banging, Patrz:
manipulowanie bitami
blitting, 84
bïÈd
logiczny, 62, 74
skïadni, 62
Braben David, 16
breadboard, Patrz: pïytka
prototypowa
budka dla ptaków, 392, 422
budowa, 397, 399
oprogramowanie, 402,
410
buforowanie podwójne, 246
Bushnell Nolan, 102
C
Carpintero Angel, 291
Cellan-Jones Rory, 16
color key, Patrz: kolor
przezroczystoĂci
Compu=Prompt, 82
czcionka, 84
o staïej szerokoĂci
znaków, 88
proporcjonalna, 88
czujnik, 284, 300
do Ăledzenia
maïych ssaków, 393
ptaków, 392
DS18B20, 296, 297
Halla, 360
PIR, Patrz: czujnik ruchu
promieni, 393
detektor, 394, 398
emiter, 394, 398
rotacji, 368
ruchu, 284, 286
alarm, 288
biegun dodatni, 288
masa, 288
szum, Patrz: szum
temperatury, 296
oprogramowanie, 297,
299, 300
czytnik RFID, 264, 273, 274,
275, 276
D
dane
analiza, 400
nadmiarowe, 401
rejestrowanie, 400
Debian, 24
pakiet, 201
detektor szczytowy, 258
diagram, 412, 420
przepïywu, 74
dioda
LED, 176, 200, 206, 217,
227, 246, 368
anoda, 181, 183, 217,
317, 394
czerwona, 177, 317
jasnoĂÊ Ăwiatïa, 179
katoda, 317, 394
napiÚcie przebicia, 177
natÚĝenie prÈdu, 177
niebieska, 177
podczerwona, 394
SFH484-2 IR, 394
spadek napiÚcia, 177
taĂma, Patrz: taĂma LED
z równolegïym
ukïadem pinów, 317
z ukïadem
przeciwstawnym,
317
ze wspólnÈ anodÈ, 180
ze wspólnÈ katodÈ, 180
zielona, 177, 317
LED RGB, 176, 179, 180
display memory, Patrz:
pamiÚÊ ukïadu
graficznego
dysk twardy, 25
dziennik
bïÚdów, 344
diagnostyczny, 344
dziura, 359
děwiÚk, 110, 122, 128, 192,
196, 224, 225, 242, 245
czÚstotliwoĂÊ, 258
kompresja, 401
mono, 128
sterowanie Ăwiatïem, 258
sterownik, 39
dĝojstik, 316
testowanie, 324
426
RASPBERRY PI. NAJLEPSZE PROJEKTY
E
edytor tekstu
Leafpad, 325
nano, 292
efekt
děwiÚkowy, 127, 128
Halla, 359
elektron, 210, 359
elektrycznoĂÊ, 210
masa, Patrz: masa
napiÚcie, Patrz: napiÚcie
opór, Patrz: opór
prÈd, Patrz: prÈd
e-mail, 300, 301, 309, 343,
Patrz teĝ: poczta
elektroniczna
z raportem, 306
zaïÈcznik, 304
enkoder obrotowy, 334, 359
absolutny wykorzystujÈcy
efekt Halla, 359, 360
AS5040, 368, 373
bïÈd, 337
dane wyjĂciowe, 335
drganie styków, 335,
336, 337
oprogramowanie, 339
optyczny, 334
przyrostowy, 335
testowanie, 341, 342
wyjĂcie kwadraturowe,
335
wzglÚdny, 360
z przeïÈcznikami, 334,
335
zÈbek, 334, 337
Excel, 420
F
Facebook, 334, 342
przesyïanie rysunków, 344
Fail2Ban, 296
Fedora, 24
figura Lissajous, 359
FileZilla, 294
filtr
czÚstotliwoĂÊ graniczna,
258
dolnoprzepustowy, 258
górnoprzepustowy, 258
flat file, Patrz: plik
jednorodny
Flickr, 343
logowanie, 344, 345
powiÈzanie
z Facebookiem, 345
przesyïanie rysunków,
343, 344
format
.avi, 294
.jpg, 294
.ogg, 110, 122, 128
.png, 128
.wav, 128
MJPEG, 294
MP3, 401
tar.gz, 231
zip, 401
fotodetektor, 394
fototranzystor, 394
emiter, 395
kolektor, 395
na podczerwieñ, 394
QSW113, 395
fundacja Raspberry Pi, 16
funkcja, 50, 51
argument, 50
choice, 51
definiowanie, 53
drawBox, 245
generujÈca liczby losowe,
192
histogram, 422
importowanie, 51
input, 52
mouseGet, 246
nazwa, 54
open, 406
pakiet, Patrz: pakiet
parametr, Patrz: funkcja
argument
raw_input, 52
shuffle, 71
G
general purpose
input/output, Patrz:
zïÈcze GPIO
generator obwiedni, 260
gïoĂnik, 225, 227
Gmail, 302, 304
gniazdo, Patrz: zïÈcze
Goodin Courtney, 82
Google Docs Spreadsheets,
420
gra
kóïko i krzyĝyk, 62
Magnavox Odyssey, 102
Minecraft, 152, 154, 155
czat, 156
gracz, 158, 160, 168
instalowanie, 152, 153
labirynt, 160, 161, 163,
164, 166
materiaï, 158
uruchamianie, 153
wspóïrzÚdne, 157, 160
Pac-Man, 126
ekran, 142
tryb mocy, 126
Pie Man, 126, 135, 137,
140
plansza, 131
sprite, Patrz: sprite
warstwa, 131
Ping, 103
dla dwóch graczy, 117
dla jednej osoby, 111
ping-pong, 102
punktacja, 111
Snap, 176
děwiÚki, 192
elektronika, 179
oprogramowanie, 192
poziom trudnoĂci, 192
pudeïko, 184
testowanie, 189
grafika, 83
wspóïrzÚdne, 105
H
hakowanie, 220, 222
komputerów, 265
Hall Edwin, 359
Halla efekt, Patrz: efekt
Halla
Hancock Tony, 82
harmonograf, 358
elektronika, 368
oprogramowanie, 383
hasïo domyĂlne, 39
Higginbotham Willy, 102
histogram, 420
I
IDLE, Patrz: Ărodowisko
IDLE
image, Patrz: obraz
informatyka, 400
instrukcja
def, 226
git, 232
if, 72
import, 206
ls, 406
SKOROWIDZ
427
lsmod, 202
minecraft.Minecraft.create,
157
pass, 72
piface/scripts/
piface-emulator, 205
print, 50, 228
startx, 39
sudo, 28, 301
sudo reboot, 202
tar, 231
tar –zxvf, 153
time.sleep, 149
Integrated Development
Environment, Patrz:
Ărodowisko IDE
interfejs
graficzny, 39
PiFace Digital, 16
SPI, 360
internet, 36
rzeczy, Patrz: IOT
internet of things, Patrz:
IOT
IOT, 284
J
jarzmo testowe, 66
jÚzyk
C, 361
C++, 361
Python, Patrz: Python
K
kamera internetowa, 290,
291, 294, 392
obraz w internecie, 295
karta
interfejsowa, 200
PiFace, 176, 179
bufor, 254
dioda LED, 246
emulator, 204, 207, 208
inicjowanie, 228
konfigurowanie, 254
przekaěnik, 245,
254, 314
wejĂcie, 207, 208
wyjĂcie, 254, 256
PiFace Digital, 200, 204,
222, 227, 268, 394
emulator, 395
konfiguracja, 200,
201, 202
oprogramowanie, 201,
202
podïÈczanie, 204
przekaěnik, 211
tranzystor, 212
wejĂcie, 211
wyjĂcie, 211
wyjĂcie otwartego
kolektora, 211, 217
zïÈcze, 209, 211
SD, 24, 25, 26
tworzenie, 26
katalog, 406
klasa, 228, 280
metoda, Patrz: metoda
szczelnoĂci IP, 399
klawiatura
sterownik, 39
ze zïÈczem USB, 32
klawisz
Home, 122
Page Down, 122
Page Up, 122
klient
FTP, 294
SSH, 291, 296
klucz, 277
kod, Patrz: program
Graya, 337
kolektor otwarty, 212, 217,
218, 288
kolor, 245, Patrz teĝ: barwa
przezroczystoĂci, 131
komentarz, 107, 202
komparator, 258
kompas elektroniczny, 359
komponent, 199, 214
do montaĝu
powierzchniowego,
180, 182
przewlekany, 180, 181
kompresja
bezstratna, 401
stratna, 401
zip, 401
komunikat, 228
konsola tekstowa, 63
kontaktron, 285
krotka, 167, 245
kurczak twittujÈcy, 220
L
lampka, 40
Lang Jack, 16
latencja, Patrz: opóěnienie
Lavrsen Kenneth, 291
LeafPad, 44
LED, Patrz: dioda LED
LibreOffice, 420
light emitting diode, Patrz:
dioda LED
lightweight directory access
protocol, Patrz: protokóï
LDAP
Linux, 24, 25, 27, 28, 39,
280, 361
Arch, Patrz: Arch
Debian, Patrz: Debian
dystrybucja, 24
Fedora, Patrz: Fedora
instrukcja sudo, Patrz:
instrukcja sudo
openSUSE, Patrz:
openSUSE
Raspbian Wheezy, 152
Red Hat, Patrz: Red Hat
Ubuntu, Patrz: Ubuntu
ustawienia lokalne, 405
Lissajous figura, 359
lista, 50, 51, 63, 67, 167
list, 65
sortowanie, 196
Lomas Pete, 16
lutowanie, 215
LXTerminal, 39
ïañcuch znaków, 49
ïoĝysko, 367
M
magistrala SPI, 200, 202
uprawnienia, 204
magnes, 367
cylindryczny
namagnetyzowany
wzdïuĝ Ărednicy, 360,
365
manipulowanie bitami, 373
masa, 210, 211
maszyna stanowa, 412
implementacja, 412
metoda, 228
__init__, 228
inicjujÈca, 228
pfio, 228
Microsoft Windows, Patrz:
Windows
miernik prÈdu bezstykowy,
359
428
RASPBERRY PI. NAJLEPSZE PROJEKTY
mikrofon, 259
monitor, 32, 96
VGA, 33, 34
Motion, 291
demon, 293
instalowanie, 292
konfiguracja, 293
skrypt Pythona, 294
Mullins Rob, 16
Mycroft Alan, 16
mysz, 32, 156
N
nadajnik podczerwieni, 394
napiÚcie, 210
notacja wielbïÈdzia, 54, 157
O
obiekt, 228
pygame, 244
obraz, 26, 29, 38
przesyïanie, 26
obwód
równolegïy, 222
szeregowy, 221, 222
odbiornik astabilny, 307
odpytywanie, 339
Ohma prawo, Patrz: prawo
Ohma
okna otwieranie, 242
openSUSE, 24
opór, 210
opóěnienie, 110
Oppenheimer Jess, 82
oprogramowanie Motion,
Patrz: Motion
OS X, 24, 27, 29
oscyloskop, 102
P
pakiet
folders2flickr, 343, 344
piface, 245
pygame, 242
random, 51
pamiÚÊ, 25
adresowanie, 25
blok, 25, 26
bufor, 246, 408
obraz, Patrz: obraz
robocza, 83
suma kontrolna, Patrz:
suma kontrolna
ukïadu graficznego, 83
para klucz – wartoĂÊ, 277
pendrive, 25
pÚtla, 54, 412
for, 54, 55, 64
nieskoñczona, 56
while, 54, 55, 56
z licznikiem, 55
piksel, 83
analiza, 126
pilot bezprzewodowy, 306
oprogramowanie, 309
plik
.flickrToken, 345
archiwizacja, 152
dziennik bïÚdów, 344
dziennik diagnostyczny,
344
history, 344
jednorodny, 272
otwieranie, 406
tryb, 408
wielkoĂÊ bufora, 408
Ăcieĝka, 406
wykonywalny, 237
pïytka
prototypowa, 214, 261
stripboard, 261
uniwersalna, Patrz:
pïytka prototypowa
poczta elektroniczna, 291,
301, 392, Patrz teĝ: e-mail
pole
elektryczne, 359
magnetyczne, 359
polecenie, Patrz: instrukcja
port, Patrz: zïÈcze
potencjometr, 334
prawo Ohma, 210
prÈd, 210
problemy, 40, 41
procesor, 24
program
Audacity, 110
bïÈd, Patrz: bïÈd
debugowanie, 228
dziaïajÈcy w czasie
rzeczywistym, 400
espeak, 224, 225
LXTerminal, 153, Patrz:
LXTerminal
ïÈczenie, 414
Modprobe, 297
Motion, Patrz: Motion
NOOBS, 26, 152
Pendulum Pi, 383, 388
Photoshop Elements, 128
przerywanie pracy, 56
Putty, 291
sendmail.py, 301
struktura, 51, 229
testowanie, 230, 273
w tle, 293
X Server, Patrz: X Server
zapisywanie, 46
programowanie obiektowe,
228, 229, 234, 278
prompter, 92
budowa, 96
protokóï
LDAP, 280
SPI, 373
SSH, 278
przeglÈdarka, 291, 295
Dillo, 344
Internet Explorer, 294
Midori, 344
przekaěnik, 211, 270
dwustanowy, Patrz:
przekaěnik przeïÈczny
NC, 316
NO, 314, 316
przeïÈczny, 270
przeïÈcznik, 176, 180, 184,
200, 211, 216
bezstykowy, 359
drganie styków, 335, 336
filtrowanie, 416
eliminacja drgañ, 336
przechylny, 339
rtÚciowy, 339
z wbudowanÈ diodÈ LED,
217
przerwanie, 339
przetwornik
analogowo-cyfrowy, 334
przezroczystoĂÊ, 131
pulpit graficzny, 39
Python, 44, 49, 50, 152, 156
bufor, 265
czytnik RFID, 276
konsola tekstowa, Patrz:
konsola tekstowa
moduï, 232
budowanie, 230
httplib2, 230, 232
instalowanie, 202, 204
matplotlib, 420
numpy, 420, 422
odblokowywanie, 202
python-oauth2, 230, 232
python-twitter, 230, 232
random, 157
shelve, 196
simplejson, 230, 231
sys, 157
SKOROWIDZ
429
program
espeak, 225
wywoïywanie, 225, 226
skrypt, 294
staïa, 404
wciÚcia, 53, 54
wersja, 206
Q
QuickTime, 105
R
radio frequency
identification, Patrz:
RFID
Raspbian, 26, 280
Red Hat, 24
rekurencja, 80
rezystor
obniĝajÈcy, 286
podciÈgajÈcy, 286, 288
RFID, 264, 273, 274, 275
Roto-Sketch, 334
oprogramowanie, 346, 351
symetria, 351, 354
ruch, 103
kÈt, 103
kierunek, 105
odbicie, 104, 111, 112
zderzenie, Patrz:
zderzenie
ruter, 291, 295
adres IP, 295
S
Schlafly Hubert, 82
sekwenser, 247, 248
Serial Peripheral Interface,
Patrz: magistrala SPI
serial protocol interface,
Patrz: protokóï SPI
serwer
katalogowy, 280
LDAP, 280
poczty elektronicznej, 301
szyfrowanie, 302, 303,
304
WWW, 24, 25, 36
sieÊ, 24
sterownik, 39
skrypt, 294
sendmail.py, 294, 309
sïownik, 277
sïowo
def, 53
elif, 73
immutable, 160
sprite, 127
tworzenie, 128, 129
wielkoĂÊ, 127
sprzÚĝenie zwrotne
dodatnie, 259
ujemne, 259
staïa, 160, 228, 403
Python, 404
sterownik, 201
děwiÚku, Patrz: děwiÚk
sterownik
klawiatury, Patrz:
klawiatura sterownik
sieci, Patrz: sieÊ
sterownik
SPI, 201
stoper, 208, 217
strumieñ
standardowy, 414
stderr, 414
stdin, 414
stdout, 414
suma kontrolna, 27, 28, 30
MD5, 401
sygnaï
analogowy, 33, 34
cyfrowy, 33, 34
syntezator mowy, 224, 225
system
Active Directory, 280
Git, 203
kontroli wersji, 203, 343
krytyczny ze wzglÚdu na
bezpieczeñstwo, 265
nawigacji satelitarnej, 225
oparty na sprite’ach, 84
operacyjny, 24, 361
Android, Patrz: Android
Linux, Patrz: Linux
ïadowanie, 36, 38
OS X, Patrz: OS X
Windows, Patrz:
Windows
plików, 25
ext, 25
FAT, 25, 26
HFS Plus, 25
hierarchiczny, 406
katalog, 279
NTFS, 25
subversion, 343
transmodulacji, 176
wbudowany, 198
sztuczna inteligencja, 70
szum, 400, 415
filtrowanie, 416
¥
Ărodowisko
IDE, 44
Arduino, 361, 372
IDLE, 44, 156, 157, 242
funkcja, 52
uruchamianie, 45
wersja, 45, 206
zapisywanie kodu, 46
IDLE 3, 45, 52
okienkowe, 153, 242
T
tabela rekordów, 196
tablica
asocjacyjna, 277
wyszukiwañ, 84
z haszowaniem, 277
taĂma LED, 254, 255, 256, 257
teleprompter, 82, 83, Patrz
teĝ: prompter
teoria informacji, 400
terminal, 39, 153
Terminal, 29
test harness, Patrz: jarzmo
testowe
tor z samochodzikami, 314
kod gry, 327
oprogramowanie, 325
testowanie, 316
Torvalds Linus, 24, 203
tranzystor, 212
baza, 308
bipolarny, 308
emiter, 308
kolektor, 308
NPN, 212
Twitter, 220, 230, 392
komunikacja, 233, 234
token, 233
uwierzytelnianie, 233
U
Ubuntu, 24
Upton Eben, 16
urzÈdzenie
analogowe, 200
cyfrowe, 200
nieliniowe, 176
Wi-Fi, 295
430
RASPBERRY PI. NAJLEPSZE PROJEKTY
usïuga
katalogowa, 279
SSH, 291, 296
ustawienia lokalne, 405
uĝytkownik
domyĂlny, 39
root, 28, 291
V
Vreeken Jeroen, 291
W
wahadïo, 358, 359, 361, 362,
367, 388
amplituda, 359
masa, 362
okres, 362
wspóïczynnik tïumienia,
362
wartoĂÊ logiczna, 245
wiersz poleceñ, 28, 29, 235
tekstowy, Patrz: terminal
Windows, 24, 27, 280
wyjĂcie kwadraturowe, 335
wykres, 420
czasowania, 335
wyïÈcznik
drzwiowy, 284, 285
normalnie otwarty,
285, 314
wzmacniacz operacyjny,
259, 260
X
X Server, 39
Y
Yahoo!, 302, 304
Z
zacisk Ărubowy, 214
zamek do drzwi, 264
elektromagnetyczny, 266
hasïo, 271, 272
kontrola drzwi, 268
oprogramowanie, 270,
271, 276
schemat, 264
symulacja programowa,
267
testowanie, 278
uwierzytelnianie, 271,
272, 276, 280
typu wyzwanie –
odpowiedě, 275
z elektromechanicznym
zatrzaskiem, 266
zapora, 296
zasilanie, 38, 41
problemy, 41
zdarzenie, 243
wciĂniÚcia przycisku
myszy, 246
zamkniÚcia programu, 243
zderzenie, 104, 111, 116
okreĂlenie miejsca, 122
zegar, 36
zïÈcze
DVI, 33
ethernetowe, 36
GPIO, 200, 284, 285, 286,
308
HDMI, 32, 225
jack, 225
mikro USB, 41
RCA, 32, 35
USB, 32
zmienna, 49, 412
bajtowa, 246
globalna, 134
mc, 157
znak
__, 230
|, 414
cudzysïów, 49
delta, 103
komentarza, 202
równoĂci, 49
theta, 104
Wyszukiwarka
Podobne podstrony:
Raspberry Pi Najlepsze projekty raspnp 2
Raspberry Pi Najlepsze projekty
Raspberry Pi Najlepsze projekty 2
Raspberry Pi Najlepsze projekty
Raspberry Pi Niesamowite projekty Szalony Geniusz rpszge
Raspberry Pi Niesamowite projekty Szalony Geniusz
Raspberry Pi Niesamowite projekty Szalony Geniusz
Raspberry Pi Niesamowite projekty Szalony Geniusz rpszge 2
Raspberry Pi Niesamowite projekty Szalony Geniusz 2
Raspberry Pi - komputer za grosze już w sprzedaży, PAMIĘTNIK
sprawko na pi nr 1 Projektowanie rozkazów dla maszyny W
PI lab 2 Projektowanie rozkazów dla maszyny W
Adafruit Ultimate GPS on the Raspberry Pi
Raspberry Pi 4
raspberry pi bplus mch
Raspberry Pi Przewodnik uzytkownika
więcej podobnych podstron