HTML5. Tworzenie gier - ebook

Możliwości nowej odsłony języka HTML są nieprawdopodobne. Jego potencjał można wykorzystać do tworzenia atrakcyjnych stron WWW, funkcjonalnych aplikacji oraz... gier! Ten język świetnie sprawdza się nawet w takiej roli. WebGL, JavaScript oraz CSS3 pozwolą Ci rozwinąć skrzydła. Już dziś możesz podjąć wyzwanie i wraz z autorem tej wspaniałej książki stworzyć swoją pierwszą grę!

"HTML5. Tworzenie gier" napisano w przeświadczeniu, że książka pomoże Ci przenieść Twoje umiejętności tworzenia stron w świat projektowania gier komputerowych. Nie ma znaczenia, czy jesteś projektantem witryn, który pragnie spróbować swoich sił w nowej dziedzinie, twórcą aplikacji Flash, zainteresowanym nową technologią, czy przyświeca Ci całkowicie inny cel. Książka pokaże Ci, jak użyć dobrze znanych narzędzi, by przebyć przepaść dzielącą tradycyjne witryny od ekscytujących gier. W trakcie lektury poznasz elementy składowe gry oraz charakterystykę urządzeń mobilnych. Zorientujesz się, jakie są kolejne etapy procesu wytwarzania nowej aplikacji. Nauczysz się tworzyć wielowątkowe rozwiązania dzięki technologii Web Workers oraz rysować atrakcyjne elementy graficzne przy użyciu elementu canvas. Z kolejnych rozdziałów dowiesz się, jak oprogramować sterowanie ruchem oraz jak przygotować efekty dźwiękowe dla Twojej gry, a potem poznasz tajniki tworzenia grafiki 3D oraz przechowywania danych lokalnie w przeglądarce użytkownika. Książka ta w sposób kompleksowy podchodzi do tematu tworzenia gier w języku HTML5. Jeżeli masz choć trochę zapału, dzięki niej z pewnością osiągniesz cel!

Już wkrótce będziesz mógł:

• zaprojektować swoją wyjątkową grę
• stworzyć zaawansowaną grafikę przy użyciu canvas i WebGL
• przechowywać dane lokalnie w bazie danych przeglądarki
• korzystać z wielowątkowości dzięki Web Workers

Wstęp (13)

Część I. Wstęp do gier w standardzie HTML5 (17)

Rozdział 1. Gry w sieci (19)

• HTML5 - rys historyczny (20)
  
• HTML5 a gry (20)
  
  • Element canvas (21)
  • Dźwięk (22)
• WebSocket (23)
  
  • Magazyn sieciowy (24)
  • WebGL (24)
  • HTML5 (nie) jest pogromcą Flasha (25)
• Gwarantowanie wstecznej kompatybilności (25)
  
  • Wykrywanie własności (25)
  • Używanie biblioteki Modernizr (26)
  • Wypełnianie luk (26)
• Konstruowanie gry (27)
  
• Podsumowanie (28)

Rozdział 2. Pierwsze kroki (29)

• Planowanie gry (30)
  
  • Dopasowywanie brylantów (30)
  • Dopasowywanie (30)
  • Etapy gry (31)
• Definiowanie warstw gry (31)
  
  • Ekran powitalny (31)
  • Menu główne (31)
  • Gra (32)
  • Rekordowe wyniki (32)
• Tworzenie szkieletu aplikacji (33)
  
  • Struktura HTML (34)
  • Nadawanie stylu (34)
  • Wczytywanie skryptów (36)
• Projektowanie ekranu powitalnego (40)
  
  • Używanie fontów sieciowych (40)
  • Formatowanie ekranu powitalnego (41)
• Podsumowanie (43)

Rozdział 3. HTML i urządzenia mobilne (45)

• Tworzenie aplikacji sieciowych na urządzenia przenośne (46)
  
  • Napisz raz a dobrze (46)
  • Platformy mobilne - wyzwania (47)
• Obsługa sterowania na urządzeniu mobilnym (47)
  
  • Sterowanie za pomocą klawiatury (47)
  • Mysz kontra dotyk (48)
• Przystosowywanie gry do niskiej rozdzielczości (49)
  
• Projektowanie skalowalnych układów strony (50)
  
  • Kontrolowanie przestrzeni operacyjnej (51)
  • Wyłączenie skalowania (52)
• Tworzenie różnych widoków (52)
  
  • Tworzenie głównego menu (53)
  • Dodawanie modułów ekranu (54)
  • CSS i zapytania medialne (57)
  • Wykrywanie orientacji urządzenia (58)
  • Dodawanie mobilnych arkuszy stylów (59)
• Tworzenie gier na systemy iOS i Android (61)
  
  • Umieszczanie aplikacji na ekranie głównym telefonu (61)
  • Usunięcie interfejsu przeglądarki (68)
• Debugowanie aplikacji mobilnych (71)
  
  • Włączanie debugera Safari (71)
  • Uzyskanie dostępu do logów w Androidzie (73)
• Podsumowanie (73)

Część II. Tworzenie komponentów gry (75)

Rozdział 4. Konstruowanie gry (77)

• Tworzenie modułu planszy (78)
  
  • Inicjalizowanie stanu gry (79)
  • Wypełnianie planszy (81)
• Implementacja zasad (83)
  
  • Walidacja ruchów gracza (83)
  • Wykrywanie łańcuchów (85)
  • Generowanie nowych klejnotów (87)
  • Przyznawanie punktów (88)
  • Ponowne wypełnianie siatki (89)
  • Dopasowywanie brylantów (92)
• Podsumowanie (93)

Rozdział 5. Pracownicy i delegowanie zadań (95)

• Pracownicy sieciowi (96)
  
  • Pracownicy - ograniczenia (96)
  • Możliwości pracowników sieciowych (97)
• Korzystanie z pracowników (98)
  
  • Wysyłanie wiadomości (98)
  • Otrzymywanie wiadomości (99)
  • Przechwytywanie błędów (99)
  • Współdzieleni pracownicy (100)
  • (Nie) Pierwszy przykład (101)
• Wykorzystywanie pracowników w grach (103)
  
  • Tworzenie modułu pracownika (104)
  • Utrzymanie starego interfejsu (105)
• Podsumowanie (110)

Rozdział 6. Element canvas i grafika (111)

• Grafika w sieci (112)
  
  • Obrazy bitmapowe (112)
  • Grafika SVG (112)
  • Element canvas (113)
  • Element canvas - najlepsze rozwiązanie? (113)
• Rysowanie na elemencie canvas (114)
  
  • Rysowanie ścieżek i figur (115)
  • Łuki i okręgi (117)
  • Zaawansowane style wypełniania i konturowania (121)
  • Transformacje (124)
  • Dołączanie tekstu, obrazu i cieni (126)
  • Dodawanie tekstu (127)
  • Zarządzanie stosem stanów (130)
  • Rysowanie logo HTML5 (131)
  • Kompozycje (135)
• Manipulowanie danymi obrazu (136)
  
  • Odczytywanie wartości pikseli (136)
  • Uaktualnianie wartości pikseli (137)
  • Eksport danych obrazu (139)
  • Bezpieczeństwo i nałożone ograniczenia (139)
  • Tworzenie efektów specjalnych na poziomie pikseli (140)
• Podsumowanie (141)

Rozdział 7. Tworzenie szaty graficznej gry (143)

• Wstępne ładowanie plików (144)
  
  • Dopasowanie wielkości obrazów (144)
  • Modyfikowanie skryptu ładowania (145)
  • Pasek postępu (149)
• Upiększanie tła (151)
  
• Konstruowanie ekranu gry (153)
  
  • Nanoszenie planszy na płótno (154)
  • Definiowanie planszy bez użycia płótna (160)
• Podsumowanie (165)

Rozdział 8. Interakcja w grze (167)

• Identyfikowanie działań użytkownika (168)
  
  • Zdarzenia obsługi myszy a ekrany dotykowe (168)
  • Wirtualna klawiatura (168)
  • Zdarzenia dotykowe (170)
  • Zdarzenia sterowania i płótna (174)
• Konstruowanie modułu sterowania (176)
  
  • Obsługa zdarzeń sterowania (177)
  • Implementowanie mechaniki gry (180)
  • Powiązanie kontrolek z funkcjami gry (184)
• Podsumowanie (189)

Rozdział 9. Animowanie grafiki w grze (191)

• Wdrażanie interakcji (192)
  
  • Synchronizacja animacji (193)
  • Animowanie znacznika (196)
  • Animowanie działań w grze (197)
• Punkty i czas (206)
  
  • Tworzenie elementów interfejsu użytkownika (207)
  • Tworzenie licznika czasu (210)
  • Przyznawanie punktów (211)
  • Koniec gry (219)
• Podsumowanie (222)

Część III. Efekty 3D i dźwięk (223)

Rozdział 10. Efekty dźwiękowe w grach (225)

• HTML5 i dźwięk (226)
  
  • Wykrywanie obsługi audio (226)
  • Wojny formatów - przebieg konfliktu (227)
  • Odnajdywanie efektów dźwiękowych (229)
• Używanie elementu audio (229)
  
  • Sterowanie odtwarzaniem (232)
  • Dźwięk a urządzenia mobilne (235)
• Dane audio (235)
  
  • Korzystanie z API danych Mozilla (236)
  • Kilka przykładów (237)
• Konstruowanie modułu audio (241)
  
  • Przygotowanie do odtwarzania dźwięku (242)
  • Odtwarzanie efektów dźwiękowych (242)
  • Zatrzymywanie dźwięku (244)
  • Sprzątanie (244)
• Dołączanie efektów dźwiękowych do gry (245)
  
  • Odtwarzanie dźwięku w ekranie gry (245)
• Podsumowanie (247)

Rozdział 11. WebGL i grafika 3D (249)

• Trzeci wymiar w sieci (250)
  
  • Wprowadzenie do WebGL (250)
  • Debugowanie w WebGL (251)
  • Tworzenie modułu pomocniczego (252)
• Shadery (252)
  
  • Zmienne i typy danych (252)
  • Shadery WebGL - praktyczne zastosowanie (256)
  • Zmienne jednolite (260)
  • Zmienne różnorodne (262)
• Renderowanie trójwymiarowych obiektów (262)
  
  • Korzystanie z buforów wierzchołków (263)
  • Używanie buforów indeksów (264)
  • Korzystanie z modeli, widoków i projekcji (265)
  • Macierz widoku modelu (266)
  • Renderowanie (268)
  • Ładowanie modeli Collada (271)
• Wykorzystywanie tekstur i oświetlenia (273)
  
  • Dodawanie oświetlenia (273)
  • Oświetlenie pikselowe (276)
  • Tworzenie tekstur (278)
• Tworzenie modułu wyświetlania WebGL (283)
  
  • Ładowanie plików WebGL (284)
  • Przygotowanie modułu WebGL (285)
  • Renderowanie klejnotów (287)
  • Animowanie klejnotów (292)
• Podsumowanie (294)

Część IV. Magazyn lokalny i tryb gry dla wielu graczy (295)

Rozdział 12. Magazyn lokalny i tryb cache'owania (297)

• Magazynowanie danych - magazyn sieciowy (298)
  
  • Używanie interfejsu magazynu (298)
  • Konstruowanie modułu magazynu (301)
• Zapisywanie stanu gry na stałe (303)
  
  • Zamknięcie gry (303)
  • Pauzowanie gry (305)
  • Zapisywanie danych gry (306)
• Tworzenie listy najlepszych wyników (308)
  
  • Konstruowanie ekranu wyników (309)
  • Przechowywanie rekordowych wyników (311)
  • Wyświetlanie rekordowych wyników (312)
• Pamięć podręczna aplikacji (313)
  
  • Manifest pamięci podręcznej (313)
• Podsumowanie (316)

Rozdział 13. Technologia WebSocket i tryb wieloosobowy gry (317)

• Korzystanie z technologii WebSocket (318)
  
  • Nawiązywanie połączenia z serwerem (318)
  • Komunikacja w standardzie WebSocket (321)
• Stosowanie systemu Node.js po stronie serwera (322)
  
  • Node.js - instalacja (323)
  • Konstruowanie serwera HTTP (324)
  • Konstruowanie pokoju czatu w technologii WebSocket (326)
• Podsumowanie (331)

Rozdział 14. Dodatkowe zasoby (333)

• Korzystanie z oprogramowania pośredniczącego (334)
  
  • Box2D (334)
  • Impact (335)
  • Three.js (337)
• Przystosowywanie gier do działania na urządzeniach mobilnych (338)
  
  • PhoneGap (338)
  • Appcelerator Titanium (341)
• Dystrybucja gier (342)
  
  • Chrome Web Store (342)
  • Zeewe (343)
• Google Play (344)
  
  • App Store (344)
• Korzystanie z usług sieciowych (345)
  
  • TapJS (345)
  • Playtomic (345)
• JoyentCloud Node (346)
  
• Podsumowanie (346)

Część V. Dodatki (349)

Dodatek A. Element canvas - zbiór odwołań (351)

• Element canvas (352)
  
• API kontekstu dwuwymiarowego (352)
  
  • Zarządzanie stanem (352)
  • Transformacje (353)
  • Figury i ścieżki (354)
  • Wypełnienia i linie (356)
  • Cienie (357)
  • Obrazy (358)
  • Tekst (358)
  • Kompozycje (359)
  • Manipulowanie pikselami (360)
  • Dostępność (361)

Dodatek B. WebGL - zbiór odwołań (363)

• API WebGL - zbiór odwołań (364)
  
  • Typy danych (364)
  • Typy tablic (365)
  • Bufory (365)
  • Shadery (366)
  • Obiekty programów (367)
  • Zmienne jednolite (368)
  • Atrybuty wierzchołków (369)
  • Rysowanie (370)
  • Tekstury (371)
  • Mieszanie i wtapianie (373)
  • Bufor szablonu (374)
  • Bufor głębi (375)
  • Bufory renderowania (376)
  • Bufory ramki (377)
  • Inne funkcje (378)
  • Parametry (380)

Dodatek C. OpenGL Shading Language (385)

• Język GLSL ES - zbiór odwołań (386)
  
  • Typy danych (386)
  • Funkcje wbudowane (387)
  • Wbudowane zmienne i stałe (393)

Skorowidz (395)