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)

• Tytuł: HTML5. Tworzenie gier
• Autor: Jacob Seidelin
• Tytuł oryginału: HTML5 Games: Creating Fun with HTML5, CSS3, and WebGL
• Tłumaczenie: Maciej Reszotnik
• ISBN: 978-83-246-6612-6, 9788324666126
• Data wydania: 2012-11-13
• Format: Ebook
• Identyfikator pozycji: htm5tg
• Wydawca: Helion