Zaawansowane wyszukiwanie
  Strona Główna » Sklep » Języki programowania » Programowanie mobilne » Moje Konto  |  Zawartość Koszyka  |  Do Kasy   
 Wybierz kategorię
Algorytmy Wzorce UML
Bazy danych
Bezpieczeństwo
Bioinformatyka
Biznes Ekonomia Firma
Chemia
DTP Design
E-biznes
Ekonometria
Elektronika Elektrotechnika
Energetyka
Fizyka
GIS
Grafika użytkowa
Hardware
Informatyczne systemy zarządzania
Informatyka w szkole
Języki programowania
  Ajax
  Asembler
  ASP ASP.NET
  C
  C#
  C++
  C++ Builder
  CGI Perl
  Chmura obliczeniowa
  CVS
  Delphi
  Eclipse
  Fortran
  Inne
  Java Hibernate GWT
  JavaScript
  JBuilder
  JSP JavaServlet
  PHP
  Programowanie mobilne
  Programowanie w Windows
  Prolog
  Python Django
  React
  Ruby Rails
  TypeScript
  Visual Studio
Matematyka
Multimedia
Obsługa komputera
Office
Poradniki
Programowanie gier
Programy inżynierskie
Programy matematyczne
Słowniki
Serwery
Sieci komputerowe
Systemy operacyjne
Technika
Telekomunikacja
Tworzenie stron WWW

Zobacz pełny katalog »
 Wydawnictwo:
 MsPress
Training Kit 70-290 Zarządzanie i obsługa środowiska Microsoft Windows Server 2003 MCSA/MCSE Wydanie 2

Training Kit 70-290 Zarządzanie i obsługa środowiska Microsoft Windows Server 2003 MCSA/MCSE Wydanie 2

92.40zł
78.54zł
Profesjonalne tworzenie gier internetowych dla systemu Android w językach HTML5, CSS3 i JavaScript 79.00zł
Profesjonalne tworzenie gier internetowych dla systemu Android w językach HTML5, CSS3 i JavaScript

Tytuł: Profesjonalne tworzenie gier internetowych dla systemu Android w językach HTML5, CSS3 i JavaScript
Autor: Juriy Bura, Paul Coates
ISBN: 978-83-246-7401-5
Ilość stron: 512
Data wydania: 09/2013
Oprawa: Miękka
Format: 158x235
Wydawnictwo: Helion
Cena: 79.00zł


Odnieś sukces na rynku gier!

Potencjał HTML5, CSS3 i JavaScriptu pozwala na tworzenie niesamowitych gier i aplikacji. Dzięki tym technologiom powstało oprogramowanie działające w mobilnej przeglądarce internetowej. Jeżeli dodamy do tego moc współczesnych telefonów i tabletów działających w oparciu o system Android, może się okazać, że to trio stanowi niezastąpiony zestaw narzędzi.

Dzięki tej książce rozwiniesz swoje umiejętności programistyczne! W trakcie lektury dowiesz się, jak najszybciej rozpocząć przygodę z grami dla platformy Android. W kolejnych rozdziałach nauczysz się korzystać z grafiki i animacji w przeglądarce, obsługiwać zdarzenia i operacje wykonywane przez użytkownika oraz stosować różne sposoby renderowania świata gry.

Zbudujesz też swój własny silnik izometryczny oraz wykorzystasz WebGL do stworzenia zaawansowanej grafiki 3D. Dodatkowo zdobędziesz wiedzę na temat programowania sztucznej inteligencji oraz zapewniania komunikacji aplikacji z serwerem. W tej chwili tylko krok dzieli Cię od tworzenia gier w trybie multiplayer! Książka ta jest doskonałym i kompletnym źródłem informacji dla wszystkich osób chcących wykorzystać platformę Android i przeglądarkę internetową do pisania zaawansowanych i atrakcyjnych gier.

Stwórz grę:

  • działającą na platformie Android
  • wykorzystującą mistrzowskie trio: HTML5, CSS3 i JavaScript
  • zawierającą zaawansowane elementy graficzne 3D
  • dla wielu graczy
  • i odnieś sukces!

Niezastąpiony podręcznik dla każdego programisty tworzącego gry.

Spis treści:

CZĘŚĆ I. ŚWIATY DWUWYMIAROWE

Rozdział 1. Zaczynamy (23)

  • Narzędzia (24)
    • Co jest nam potrzebne? (24)
    • Java Development Kit (27)
    • Zintegrowane środowisko programistyczne (27)
    • Serwer stron internetowych (WWW) (33)
    • SDK systemu Android i emulator (34)
  • Techniki (38)
    • Kod (38)
    • Programowanie zorientowane obiektowo (43)
    • Słowo o przeglądarkach mobilnych (51)
  • Podsumowanie (51)

Rozdział 2. Grafika w przeglądarce - płótno (53)

  • Gry od podszewki (53)
  • Rysowanie wewnątrz przeglądarki (55)
  • Podstawowe ustawienia strony HTML (55)
  • Czym jest płótno? (56)
    • Kontekst (57)
    • Układ współrzędnych (58)
  • Rysowanie kształtów (61)
    • Prostokąty (62)
    • Ścieżki (63)
    • Podścieżki (71)
  • Kontury i wypełnienia (72)
    • Kolory jednolite (73)
    • Gradienty (73)
    • Wzorce (77)
  • Stan kontekstu a przekształcenia (79)
    • Przesunięcie (80)
    • Skalowanie (81)
    • Obrót (82)
    • Grupowanie transformacji (82)
    • Stan kontekstu (84)
    • Przekształcenia kontekstu w praktyce (85)
  • Widok przykładowego projektu - efekt końcowy (86)
  • Podsumowanie (89)

Rozdział 3. Tworzymy pierwszą grę! (91)

    • Podstawowy szkielet (92)
    • Wymuszanie orientacji (96)
  • Architektura gry (98)
  • Tworzymy grę (99)
    • Renderowanie planszy (100)
    • Stan i logika gry (105)
    • Scalanie komponentów - klasa Game (110)
  • Podsumowanie (115)

Rozdział 4. Animacje i sprite'y (117)

  • Sprite'y (118)
    • Wczytywanie obrazków (119)
    • Rysowanie obrazka (129)
    • Arkusze sprite'ów (133)
  • Podstawy animacji (136)
    • Najprostsza animacja (136)
    • Wątki a JavaScript (137)
    • Timery (138)
    • Poprawianie jakości animacji (141)
  • Podsumowanie (153)

Rozdział 5. Obsługa zdarzeń i zachowań użytkownika (155)

  • Zdarzenia w przeglądarce (156)
    • Przeglądarka stacjonarna a wejście przeglądarki systemu Android (156)
    • Stosowanie zdarzeń do przechwytywania wejścia użytkownika (157)
    • Co jeszcze kryje się za zdarzeniami? (160)
    • Sposób obsługi różnic pomiędzy interfejsami dotykowymi a myszą (162)
  • Własne zdarzenia (165)
  • Generatory i funkcje nasłuchujące własnych zdarzeń (166)
    • EventEmitter - klasa bazowa (166)
    • Zdarzenia a wywołania zwrotne (169)
  • Własne zdarzenia (170)
    • Implementacja klasy InputHandlerBase (173)
    • Tworzymy klasę MouseInputHandler (176)
    • Tworzymy klasę TouchInputHandler (178)
  • Zaawansowane operacje wejściowe (179)
    • Przeciągnij i upuść (179)
    • Doskonałe wybieranie a maski obrazków (181)
    • Złożone operacje (182)
  • Symulowanie dżojstika (185)
  • Podsumowanie (188)

Rozdział 6. Renderowanie wirtualnych światów (189)

  • Mapy z kafelków (189)
    • Zasada działania map kafelkowych (190)
    • Implementacja mapy kafelków (191)
    • Mierzymy FPS (196)
  • Optymalizacja wydajności renderowania (198)
    • Rysuj tylko to, co potrzebne (198)
    • Bufor pozaekranowy (200)
    • Przechowywanie okolic obszaru widoku w pamięci (203)
  • Obiekty świata gry (206)
    • Układy współrzędnych (206)
    • Implementacja klasy WorldObjectRenderer (208)
    • Porządek sortowania (211)
    • Optymalizacje (213)
  • Widok izometryczny (214)
  • Podsumowanie (217)

Rozdział 7. Tworzymy silnik izometryczny (219)

  • Konfiguracja (220)
    • Plan (221)
    • Przygotowanie przestrzeni roboczej (222)
    • Podstawowy kod (222)
    • Przydatne mechanizmy (225)
  • Teren izometryczny (231)
    • Układy współrzędnych (231)
    • Renderowanie kafelków (232)
    • Implementowanie klasy IsometricTileLayer (237)
  • Renderowanie obiektów (244)
    • Implementacja klastrów obiektów (248)
    • Pamięć podręczna obiektów (250)
    • Obsługa ruchu (253)
    • Obiekty złożone (255)
    • Warstwa obiektów - kolejne czynności (257)
  • Brudne prostokąty (257)
    • Jak to działa? (258)
    • Implementacja (259)
    • Integracja z warstwami (263)
    • Oznaczanie brudnych prostokątów (266)
  • Interfejs użytkownika a menedżer warstw (268)
    • Menedżer warstw (268)
    • Interfejs użytkownika (271)
  • Interakcja (274)
    • Propagowanie i obsługa zdarzeń (275)
    • Zatrzymywanie propagowania zdarzeń (278)
  • Podsumowanie (279)

CZĘŚĆ II. ŚWIATY TRÓJWYMIAROWE

Rozdział 8. 3D w przeglądarce (281)

  • Renderowanie 3D - wprowadzenie (282)
  • Jak działa renderowanie 3D? (283)
    • Przekształcenia matematyczne (283)
    • Przykład w trójwymiarze (283)
  • Uproszczony silnik 3D (285)
    • Model i scena (286)
    • Renderowanie (287)
  • Podsumowanie (299)

Rozdział 9. WebGL (301)

  • Podstawy WebGL (302)
    • Inicjalizacja WebGL (302)
    • Geometrie (304)
    • Potok renderowania OpenGL ES 2.0 (305)
    • Stosowanie buforów (307)
    • Shadery i GLSL (308)
  • Prosty przykład - renderujemy sześcian (313)
    • Zastosowanie shaderów na stronie internetowej (313)
    • Renderowanie aplikacji typu Witaj, świecie! (315)
  • Eksplorowanie świata WebGL (319)
    • Kolor (319)
    • Tekstury (324)
    • Ładowanie modeli (327)
  • Podsumowanie (330)

CZĘŚĆ III. ŁĄCZENIE ŚWIATÓW

Rozdział 10. Pora na serwer (331)

  • Podstawy Node.js (332)
    • Wprowadzamy bibliotekę Node.js (332)
    • Jak programować w Node.js? (333)
    • Instalacja Node.js (335)
    • Debugowanie skryptów Node.js (336)
  • Pisanie skryptów w Node.js (337)
    • Wyjątki a stos wywołań (338)
    • Globalna przestrzeń nazw a moduły Node (338)
    • Tworzymy pierwszy moduł (341)
    • Wykrywanie modułów (344)
    • Stosowanie NPM (345)
  • Node.js w praktyce - tworzymy serwer dla gry (347)
    • Frameworki do tworzenia aplikacji webowych w Node (347)
    • Najpierw podstawy (348)
    • Renderowanie stron internetowych (351)
    • Parsowanie wejścia użytkownika (355)
    • Stosowanie sesji (357)
  • Warstwa pośrednia (358)
  • Zachowanie porządku (360)
    • Zgłaszanie błędów (360)
    • Obsługa dziennika zdarzeń (364)
    • Konfiguracje serwera (366)
  • Podsumowanie (368)

Rozdział 11. Rozmawiamy z serwerem (369)

  • Ewolucja komunikacji sieciowej w przeglądarkach (369)
  • Konfiguracja serwera (371)
  • XMLHttpRequest API do obsługi żądań HTTP (372)
    • Obsługa żądania HTTP przy użyciu XHR (373)
    • Obsługa błędów w XHR (374)
    • XMLHttpRequest Level 2 (375)
    • Obsługa danych binarnych (376)
  • Odwrotny Ajax (378)
    • Problem (378)
    • Rozwiązania (378)
    • Najlepsze rozwiązania (379)
    • Dopuszczalne rozwiązania (380)
    • Przestarzałe rozwiązania (385)
  • Testujemy transporty (386)
    • DDMS (386)
    • Symulowanie złych warunków sieci przy użyciu zewnętrznego oprogramowania (387)
  • Podsumowanie (388)

Rozdział 12. Tworzymy grę sieciową (389)

  • Architektura gry sieciowej (389)
    • Architektura gry - od jednego do wielu graczy (391)
    • Struktura projektu (393)
  • Lobby w grze przy użyciu Socket.IO (394)
    • Komunikacja klient-serwer (395)
    • Dodawanie ekranu lobby do gry (397)
  • Dodawanie obsługi rozgrywki (402)
    • Współdzielenie logiki pomiędzy klientem a serwerem (403)
    • Warstwa serwerowa (404)
    • Warstwa kliencka (408)
  • Podsumowanie (414)

CZĘŚĆ IV. USPRAWNIANIE ŚWIATÓW

Rozdział 13. Sztuczna inteligencja w grach (415)

  • Czy potrzebuję AI w mojej grze? (416)
  • Wyszukiwanie ścieżek (416)
  • Grafy (418)
    • Czym jest graf? (418)
    • Implementacja grafów w języku JavaScript (420)
  • Algorytmy wyszukiwania ścieżek (424)
    • Algorytm A* (424)
    • Metody tworzenia grafu wyszukiwania ścieżek (430)
  • Podejmowanie decyzji (432)
  • Podsumowanie (435)

Rozdział 14. Silniki gier w języku JavaScript (437)

  • API graficzne, biblioteki i silniki gier (438)
    • API graficzne (438)
    • Biblioteki graficzne (439)
    • Silniki gier (440)
  • Crafty (441)
    • System komponentów encji (441)
    • Witaj, świecie! w Crafty (444)
    • Tworzymy grę w Crafty (447)
    • Ostateczna wersja (453)
  • Podsumowanie (455)

Rozdział 15. Tworzenie natywnych aplikacji (457)

  • Aplikacje natywne (458)
  • Konfiguracja Apache Cordova (PhoneGap) (459)
    • Konfiguracja narzędzia Cordova (460)
    • Konfiguracja Apache Ant (460)
  • Budowanie aplikacji natywnej (461)
    • Tworzenie pustego projektu dla systemu Android (461)
    • Testowanie szkieletu aplikacji Android (462)
    • Podstawowy projekt Cordova (463)
    • Obsługa sieci (467)
    • Ostatnie modyfikacje: nazwa, ikona i tryb pełnoekranowy (468)
    • Stosowanie natywnych API (471)
  • Przygotowanie do publikacji (473)
    • Podpisywanie aplikacji (474)
    • Publikowanie w serwisie Google Play (476)
    • Aktualizacja aplikacji (479)
  • Podsumowanie (481)

Rozdział 16. Obsługa dźwięków (483)

  • Dźwięki na stronach internetowych (484)
    • Znacznik audio (484)
    • Web Audio API (485)
    • Dźwięk w domyślnej przeglądarce systemu Android (486)
  • Stosowanie biblioteki SoundManager2 (487)
    • Wstępna konfiguracja (487)
    • Odtwarzanie w pętli (489)
    • Obsługa dźwięku w grze (490)
  • Odtwarzanie dźwięków w aplikacjach Cordova (493)
  • Doświadczenie użytkownika (493)
  • Podsumowanie (494)
  • Co dalej? (494)

Dodatek A. Debugowanie aplikacji klienckich w JavaScripcie (495)

  • Przykład do zdebugowania (495)
  • Debugowanie w przeglądarce stacjonarnej (496)
  • Debugowanie urządzeń mobilnych (499)
  • Rejestrowanie informacji (niemal) bez zmian w kodzie (500)
  • weinre (502)
  • Podsumowanie (503)
Profesjonalne tworzenie gier internetowych dla systemu Android w językach HTML5, CSS3 i JavaScript
--- Pozycja niedostępna.---
Klienci, którzy kupili „Profesjonalne tworzenie gier internetowych dla systemu Android w językach HTML5, CSS3 i JavaScript”, kupili także:

Android w praktyce Projektowanie aplikacji, Roman Wantoch-Rekowski, Wydawnictwo Naukowe PWN

Android Programowanie gier na tablety, Jeremy Kerfs, Wydawnictwo Helion

CSS3. Kaskadowe arkusze stylów Ćwiczenia praktyczne, Witold Wrotek, Wydawnictwo Helion

Android Studio w 24 godziny. Wygodne programowanie dla platformy Android. Wydanie IV, Carmen Delessio, Lauren Darcey, Shane Conder, Wydawnictwo Helion

Mobile Web Rusz głową!, Lyza Danger Gardner, Jason Grigsby, Wydawnictwo Helion

Projektowanie systemów CMS przy użyciu PHP i jQuery, Kae Verens, Wydawnictwo Helion

piątek, 29 marca 2024   Mapa strony |  Nowości |  Dzisiejsze promocje |  Koszty wysyłki |  Kontakt z nami