Java jest nowoczesnym i prostym językiem programowania zorientowanym obiektowo. Trudno nie doceniać jej zalet -- czytelna i zrozumiała składnia, uniwersalny, niezależny od platformy kod i przede wszystkich bezpłatny dostęp do doskonałych narzędzi programistycznych. Javę doceniło już wielu twórców oprogramowania, wśród których brakowało jednak twórców gier i aplikacji "rozrywkowych". Dotychczas w Javie tworzono jedynie proste układanki, gry karciane i łamigłówki lub nieśmiertelne aplety typu "padający śnieg", które przez długi czas straszyły nas z przeglądarek internetowych. Czas na zmianę! Wykorzystaj swoje umiejętności programowania w Javie, sięgnij po wiadomości zawarte w tej książce i napisz prawdziwą grę -- z grafiką, inteligentnymi przeciwnikami, wydajnym silnikiem 3D wspomaganym sprzętowo i przestrzennym dźwiękiem.

"Java. Tworzenie gier" to książka o programowaniu gier, na jaką czekałeś. Zawiera zarówno opis podstawowych mechanizmów używanych w grach, jak i szczegółowe omówienie zaawansowanych technik. Dowiesz się, jak wykorzystać platformę Java 1.4 do tworzenia szybkich, pełnoekranowych gier akcji, przygodówek i trójwymiarowych strzelanek. Nauczysz się tworzyć wspomaganą sprzętowo grafikę, algorytmy sztucznej inteligencji i znajdowania drogi, realistyczne efekty dźwiękowe i mechanizmy obsługi gry dla wielu graczy.

• Algorytmy wyświetlania grafiki 2D
• Tworzenie interfejsu użytkownika z wykorzystaniem komponentów Swing
• Programowanie efektów dźwiękowych działających w czasie rzeczywistym
• Klient i serwer gry wieloosobowej
• Wyświetlanie grafiki 3D
• Mapowanie tekstur i symulacja oświetlenia
• Drzewa BSP
• Algorytmy detekcji kolizji i wykrywania drogi
• Sztuczna inteligencja i tworzenie botów
• Zapisywanie stanu gry
• Optymalizacja kodu
• System sterowania grą

Udowodnij "fachowcom" krytykującym szybkość Javy, że nie mają racji. Napisz wspaniałą grę w Javie. W tej książce znajdziesz wszystkie wiadomości, które są do tego niezbędne.

Osoby które kupowały "Java. Tworzenie gier", wybierały także:

• Wprowadzenie do Javy. Programowanie i struktury danych. Wydanie XII 193,23 zł, (59,90 zł -69%)
• Spring i Spring Boot. Kurs video. Testowanie aplikacji i bezpiecze 129,00 zł, (51,60 zł -60%)
• Metoda dziel i zwyci 89,00 zł, (35,60 zł -60%)
• JavaFX. Kurs video. Wzorce oraz typy generyczne 79,00 zł, (31,60 zł -60%)
• Platforma Xamarin. Kurs video. Poziom drugi. Zaawansowane techniki tworzenia aplikacji cross-platform 99,00 zł, (39,60 zł -60%)

Spis treści

Java. Tworzenie gier -- spis treści

O Autorze (15)

Wstęp (17)

Część I Podstawy gier w języku Java (25)

Rozdział 1. Wątki w języku Java (27)

• Co to jest wątek? (28)
• Tworzenie i uruchamianie wątków w języku Java (28)
  • Rozszerzanie klasy Thread (29)
  • Implementacja interfejsu Runnable (29)
  • Użycie anonimowej klasy wewnętrznej (29)
  • Oczekiwanie na zakończenie wątku (30)
  • Uśpione wątki (30)
• Synchronizacja (30)
  • Po co nam synchronizacja? (30)
  • Jak synchronizować? (31)
  • Kiedy należy synchronizować? (32)
  • Kiedy nie synchronizować? (33)
  • Unikanie zakleszczeń (33)
• Użycie wait() oraz notify() (34)
• Model zdarzeń Javy (35)
• Kiedy używać wątków? (36)
• Kiedy nie używać wątków? (36)
• Podsumowanie: pule wątków (36)
• Podsumowanie (41)

Rozdział 2. Grafika 2D oraz animacja (43)

• Grafika pełnoekranowa (44)
  • Układ ekranu (44)
  • Kolor piksela i głębia koloru (45)
  • Częstotliwość odświeżania (46)
  • Przełączanie do trybu pełnoekranowego (46)
  • Anti-aliasing (50)
  • Który tryb graficzny należy zastosować? (51)
• Rysunki (52)
  • Przezroczystość (52)
  • Formaty plików (52)
  • Odczytywanie rysunków (53)
  • Rysunki przyspieszane sprzętowo (56)
  • Program testujący wydajność rysowania rysunków (58)
  • Animacja (61)
  • Renderowanie aktywne (64)
  • Pętla animacji (64)
• Usuwanie migotania i szarpania (67)
  • Podwójne buforowanie (67)
  • Przełączanie stron (68)
  • Odświeżanie monitora i szarpanie (70)
  • Klasa BufferStrategy (70)
  • Tworzenie zarządcy ekranów (71)
  • Duszki (78)
• Proste efekty (84)
  • Przekształcenia rysunków (84)
• Podsumowanie (89)

Rozdział 3. Interaktywność i interfejs użytkownika (91)

• Model zdarzeń AWT (94)
• Zdarzenia klawiatury (95)
• Zdarzenia myszy (99)
• Przesuwanie myszy metodą "rozglądania się" (103)
  • Ukrywanie wskaźnika myszy (107)
• Tworzenie klasy InputManager (108)
• Zastosowanie obiektu InputManager (119)
  • Zatrzymywanie gry (119)
  • Dodajemy grawitację (120)
• Projektowanie intuicyjnych interfejsów użytkownika (125)
  • Wskazówki do projektu interfejsu użytkownika (126)
• Wykorzystanie komponentów Swing (127)
  • Podstawy Swing (127)
  • Stosowanie Swing w trybie pełnoekranowym (128)
• Tworzenie prostego menu (130)
• Konfiguracja klawiatury przez użytkownika (135)
• Podsumowanie (141)

Rozdział 4. Efekty dźwiękowe oraz muzyka (143)

• Podstawy dźwięku (144)
• API Java Sound (144)
  • Otwieranie pliku dźwiękowego (145)
  • Zastosowanie interfejsu Line (145)
• Odtwarzanie dźwięków (146)
• Tworzenie architektury filtrów działających w czasie rzeczywistym (151)
• Tworzenie filtra "echo", działającego w czasie rzeczywistym (155)
• Emulacja dźwięku 3D (159)
  • Mechanizmy potrzebne do tworzenia filtra 3D (160)
  • Implementacja filtra 3D (161)
  • Testowanie filtra 3D (163)
• Tworzenie obiektu zarządzającego dźwiękiem (167)
  • Klasa Sound (167)
  • Klasa SoundManager (168)
  • Zmienne lokalne dla wątków (175)
• Odtwarzanie muzyki (176)
  • Odtwarzanie dźwięku CD (177)
  • Odtwarzanie plików MP3 i Ogg Vorbis (177)
  • Odtwarzanie muzyki MIDI (178)
  • Tworzenie muzyki adaptacyjnej (182)
• Podsumowanie (184)

Rozdział 5. Tworzenie dwuwymiarowej gry platformowej (185)

• Tworzenie mapy złożonej z kafelków (186)
  • Implementacja mapy korzystającej z kafelków (187)
  • Ładowanie mapy złożonej z kafelków (190)
  • Rysowanie mapy złożonej z kafelków (193)
  • Rysowanie duszków (195)
  • Przewijanie z paralaksą (195)
  • Premie (197)
  • Proste obiekty wrogów (200)
• Wykrywanie kolizji (207)
  • Detekcja kolizji (207)
  • Obsługa kolizji (208)
  • Kolizje duszków (212)
• Dokończenie i przyspieszanie gry (213)
• Tworzenie wykonywalnego pliku .jar (213)
• Pomysły na rozszerzenie gry (215)
• Podsumowanie (216)

Rozdział 6. Gry wieloosobowe (217)

• Rewolucja w bibliotekach wejścia-wyjścia w języku Java (219)
  • Przegląd bibliotek NIO z JDK 1.4 (220)
  • Kanały (220)
  • Bufory (223)
  • Selektory oraz klasy SelectionKey (226)
• ChatterBox, prosta aplikacja dla wielu użytkowników (227)
  • Serwer: ChatterServer (227)
  • Kompilowanie i uruchamianie serwera (233)
  • Klient: ChatterClient (235)
  • Kompilowanie i uruchamianie klienta (236)
• Szkielet serwera gry wieloosobowej (237)
  • Cele projektu i taktyka (237)
  • Projekt (238)
  • Wspólne klasy i interfejsy (242)
  • Implementacja serwera (244)
  • Klient (252)
• Przykładowa gra: RPS (kamień, papier, nożyczki) (253)
  • Klasy (253)
  • Uruchamianie gry RPS (256)
• Wykończanie gry: rozbudowa szkieletu (258)
  • Interfejs klienta (258)
  • Trwałość (258)
  • Listy znajomych, pokoje i czat (258)
• Administracja serwera (259)
  • Rejestracja zdarzeń (259)
  • Uruchamianie i wyłączanie (260)
  • Konsole administracyjne serwera (261)
  • Śledzenie gry (261)
• Zagadnienia zaawansowane (262)
  • Rozłączenia i ponowne połączenia (262)
  • Tunelowanie HTTP (263)
  • Testowanie za pomocą botów (265)
  • Te nieznośne modemy (266)
  • Profilowanie i tworzenie statystyk wydajności (266)
  • Dostrajanie wydajności (268)
• Podsumowanie (270)

Część II Grafika trójwymiarowa i zaawansowane techniki programowania gier (271)

Rozdział 7. Grafika trójwymiarowa (273)

• Typy renderowania grafiki trójwymiarowej (274)
• Nie zapominajmy o matematyce (275)
  • Trygonometria i trójkąty prostokątne (276)
  • Wektory (276)
• Podstawy grafiki trójwymiarowej (281)
• Algebra trzech wymiarów (284)
• Wielokąty (289)
• Przekształcenia przestrzeni trójwymiarowej (292)
  • Rotacje (293)
  • Hermetyzacja przekształceń rotacji i translacji (295)
  • Stosowanie transformacji (298)
  • Porządek rotacji (300)
• Prosty potok tworzenia grafiki 3D (301)
• Ruch kamery (305)
• Bryły i usuwanie niewidocznych powierzchni (305)
  • Iloczyn skalarny wektorów (307)
  • Iloczyn wektorowy wektorów (308)
  • Dodatkowe właściwości iloczynu skalarnego i wektorowego (311)
• Rysowanie wielokątów za pomocą konwertera skanującego (312)
  • Optymalizowanie konwertera skanującego za pomocą liczb stałoprzecinkowych (317)
• Przycinanie w trzech wymiarach (321)
• Ostateczny potok renderowania (324)
• Podsumowanie (332)

Rozdział 8. Mapowanie tekstur i oświetlenie (333)

• Podstawy mapowania tekstur uwzględniającego perspektywę (334)
  • Wyprowadzenie równań wykorzystywanych do mapowania tekstur (335)
• Prosty mechanizm mapowania tekstur (340)
  • Wady naszego prostego mechanizmu renderującego (347)
• Optymalizowanie mapowania tekstur (348)
  • Przechowywanie tekstur (349)
  • Prosta optymalizacja (352)
  • Rozwijanie metod w miejscu wywołania (356)
  • Przykładowy program korzystający z szybkiego mapowania tekstur (358)
• Prosty mechanizm generowania oświetlenia (359)
  • Odbicie rozproszone (359)
  • Światło otoczenia (360)
  • Uwzględnianie intensywności światła pochodzącego ze źródła światła (360)
  • Spadek intensywności światła wraz z odległością (360)
  • Implementowanie punktowego źródła światła (361)
• Implementowanie oświetlania tekstur (362)
• Tworzenie zaawansowanych trików oświetleniowych za pomocą map cieniowania (369)
  • Odnajdywanie prostokąta ograniczającego (369)
  • Stosowanie mapy cieniowania (371)
  • Budowanie mapy cieniowania (373)
  • Budowanie powierzchni (375)
  • Przechowywanie powierzchni w pamięci podręcznej (378)
  • Przykład z cieniowaniem powierzchni (384)
• Dodatkowe pomysły (385)
  • Sugerowanie głębi (385)
  • Fałszywe cienie (386)
  • Mapowanie MIP (386)
  • Interpolacja dwuliniowa (386)
  • Interpolacja trójliniowa (387)
  • Mapy wektorów normalnych i mapy głębokości (387)
  • Inne typy oświetlenia (388)
• Podsumowanie (388)

Rozdział 9. Obiekty trójwymiarowe (389)

• Usuwanie ukrytych powierzchni (390)
  • Algorytm malarza (390)
  • Odwrotny algorytm malarza (391)
  • Z-bufor (391)
  • Z-bufor z wartościami 1/z (393)
  • Obliczanie z-głębokości (396)
• Animacja trójwymiarowa (397)
  • Ruch postępowy (400)
  • Ruch obrotowy (402)
• Grupy wielokątów (407)
  • Iteracyjna obsługa wszystkich wielokątów należących do grupy (411)
• Wczytywanie grup wielokątów z pliku OBJ (413)
  • Format pliku OBJ (414)
  • Format pliku MTL (420)
• Obiekty w grze (421)
• Zarządzanie obiektami w grze (425)
• Łączenie elementów (427)
• Możliwe rozszerzenia w przyszłości (433)
• Podsumowanie (434)

Rozdział 10. Zarządzanie sceną trójwymiarową za pomocą drzew BSP (435)

• Wprowadzenie do drzew BSP (436)
• Podstawy drzew binarnych (437)
• Jednowymiarowe drzewo BSP (440)
• Dwuwymiarowe drzewo BSP (442)
  • Przykład budowy drzewa BSP (443)
  • Przykład przeglądania drzewa BSP (447)
• Implementacja dwuwymiarowego drzewa BSP (448)
  • Linia podziału BSP (450)
  • Wyznaczanie położenia punktu względem linii (450)
  • Dwójkowy podział wielokąta (454)
  • Przeglądanie drzewa BSP (455)
  • Przeglądanie poprzeczne (457)
  • Przeglądanie od przodu do tyłu (458)
  • Budowa drzewa (459)
  • Znajdowanie punktu przecięcia dwóch prostych (463)
  • Przycinanie wielokątów do linii (465)
  • Usuwanie pustych przestrzeni T-złączy (467)
  • Testowanie drzewa BSP (469)
• Rysowanie wielokątów od przodu do tyłu (471)
• Pierwszy przykład wykorzystania drzewa BSP (479)
• Rysowanie obiektów na scenie (480)
• Wczytywanie map z pliku (482)
• Łączenie elementów (486)
• Rozszerzenia (486)
• Podsumowanie (488)

Rozdział 11. Wykrywanie kolizji (489)

• Podstawy kolizji (490)
• Kolizje typu obiekt-obiekt (491)
  • Eliminowanie testów (491)
  • Sfery otaczające (493)
  • Walce otaczające (495)
  • Problem przetwarzania dyskretno-czasowego (498)
• Kolizje typu obiekt-świat (499)
  • Prostopadłościany otaczające, wykorzystywane do wykrywania kolizji z podłogami (499)
  • Znajdowanie liścia drzewa BSP dla danego położenia (500)
  • Implementacja testów wysokości podłogi i sufitu (501)
  • Prostopadłościany otaczające, wykorzystywane do testowania kolizji ze ścianami (503)
  • Punkt przecięcia z odcinkiem wielokąta reprezentowanego w drzewie BSP (504)
  • Problem narożników (508)
  • Implementacja wykrywania kolizji typu obiekt-świat (509)
• Prosty program demonstracyjny wykrywający kolizje (511)
• Obsługa kolizji z przesuwaniem (512)
  • Przesuwanie obiektu wzdłuż innego obiektu (512)
  • Przesuwanie obiektu wzdłuż ściany (515)
  • Grawitacja i płynny ruch na schodach (przesuwanie obiektu wzdłuż podłogi) (517)
  • Skakanie (520)
• Program demonstracyjny obsługujący kolizje z przesuwaniem (521)
• Rozszerzenia (522)
• Podsumowanie (522)

Rozdział 12. Odnajdywanie drogi w grze (523)

• Podstawowa wiedza na temat technik odnajdywania drogi (524)
• Pierwsze przymiarki do odnajdywania drogi w grze (524)
  • Przeszukiwanie wszerz (527)
• Podstawy algorytmu A* (530)
• Stosowanie algorytmu A* w grze (535)
• Algorytm A* w połączeniu z drzewami BSP (536)
  • Przejścia (536)
  • Implementowanie portali (537)
• Uniwersalny mechanizm odnajdywania drogi (541)
• Przygotowywanie robota PathBot (545)
• Sposoby ulepszania przeszukiwania A* (549)
• Podsumowanie (550)

Rozdział 13. Sztuczna inteligencja (551)

• Podstawy sztucznej inteligencji (552)
• Pozbawianie botów ich boskiej mocy (553)
  • "Widzenie" (554)
  • "Słyszenie" (556)
• Maszyny stanów i obsługa reakcji (559)
• Maszyny probabilistyczne (561)
  • Przydatne funkcje generujące liczby losowe (563)
• Podejmowanie decyzji (564)
• Wzorce (566)
  • Unikanie (567)
  • Atakowanie (569)
  • Uciekanie (572)
  • Celowanie (573)
  • Strzelanie (574)
• Tworzenie obiektów (575)
• Łączenie elementów (576)
  • Mózgi! (576)
  • Zdrowie i umieranie (577)
  • Dodawanie HUD-a (581)
• Uczenie się (585)
  • Wskrzeszanie botów (586)
  • Uczenie się botów (588)
  • Rozszerzenia programu demonstracyjnego (593)
• Inne podejścia do sztucznej inteligencji (593)
  • Zespołowa sztuczna inteligencja (594)
• Podsumowanie (594)

Rozdział 14. Skrypty gry (595)

• Książka kucharska skryptów: czego potrzebujemy (596)
• Implementacja powiadomień wejścia i wyjścia (597)
  • Wyzwalacze (599)
• Nasłuch obiektów gry (600)
• Skrypty (604)
  • Projektowanie skryptu (606)
  • Wbudowywanie BeanShell (608)
• Zdarzenia opóźnione (612)
  • Tworzenie zdarzeń opóźnionych w BeanShell (615)
• Łączymy wszystko razem (616)
• Rozszerzenia (617)
• Podsumowanie (619)

Rozdział 15. Trwałość - zapisywanie gry (621)

• Podstawy zapisywania gier (621)
• Wykorzystanie API serializacji do zapisywania stanu gry (623)
  • Wprowadzenie do serializacji (623)
  • Serializacja: podstawy (623)
  • Serializacja: zasady (626)
  • Serializacja: pułapki (629)
  • Zmiana domyślnego działania mechanizmu serializacji (633)
• Tworzenie zrzutu ekranu gry (636)
  • Tworzenie miniatury ze zrzutem ekranu (638)
  • Zapisywanie rysunku (639)
• Zapisywanie gier we właściwym miejscu (641)
• Podsumowanie (642)

Część III Optymalizacja i kończenie gry (643)

Rozdział 16. Techniki optymalizacji (645)

• Zasady optymalizacji (646)
• Profilowanie (646)
  • Testowanie wydajności (647)
  • Użycie programu profilującego HotSpot (647)
• HotSpot (651)
  • Optymalizacje specyficzne dla języka Java (652)
  • Eliminacja nieużywanego kodu (652)
  • Wyciąganie niezmienników pętli (653)
  • Eliminacja wspólnych podwyrażeń (653)
  • Propagacja stałych (653)
  • Rozwijanie pętli (tylko maszyna wirtualna server) (654)
  • Metody inline (654)
• Sztuczki optymalizacji (655)
  • Algorytmy (655)
  • Zmniejszanie siły operacji: przesuwanie bitów (656)
  • Zmniejszanie siły operacji: reszta z dzielenia (657)
  • Zmniejszanie siły operacji: mnożenie (657)
  • Zmniejszanie siły operacji: potęgowanie (658)
  • Więcej na temat wyciągania niezmienników pętli (658)
  • Tablice wartości funkcji (659)
  • Arytmetyka stałoprzecinkowa (662)
  • Wyjątki (662)
  • Wejście-wyjście (662)
  • Pliki mapowane w pamięci (663)
• Wykorzystanie pamięci i zbieranie nieużytków (664)
  • Sterta Java oraz zbieranie nieużytków (664)
  • Monitorowanie zbierania nieużytków (665)
  • Monitorowanie użycia pamięci (666)
  • Dostrajanie sterty (670)
  • Dostrajanie procesu zbierania nieużytków (671)
  • Redukowanie tworzenia obiektów (672)
  • Ponowne wykorzystanie obiektów (672)
  • Pule obiektów (673)
• Zauważalna wydajność (674)
  • Rozdzielczość zegara (674)
• Podsumowanie (679)

Rozdział 17. Tworzenie dźwięków i grafiki gry (681)

• Wybór wyglądu i sposobu działania gry (682)
  • Szukanie inspiracji (682)
  • Zachowywanie spójności (683)
• Zdobywanie darmowych materiałów do gry (683)
• Praca z grafikami i autorami dźwięków (684)
• Narzędzia (685)
• Tworzenie dźwięków (685)
  • Formaty plików dźwiękowych (687)
• Tworzenie tekstur i duszków (687)
  • Formaty plików graficznych (688)
  • Tworzenie tekstur bezszwowych (689)
  • Tworzenie tekstur zastępczych (690)
  • Tworzenie tekstur przejściowych (691)
  • Tworzenie wielopoziomowych tekstur (692)
• Tworzenie obrazów tytułowych i grafiki dla wyświetlaczy HUD (694)
• Tworzenie grafiki interfejsu użytkownika (694)
  • Dostosowywanie komponentów Swing (694)
• Tworzenie własnych czcionek (696)
• Podsumowanie (701)

Rozdział 18. Projekt gry i ostatnie 10% prac (703)

• Ostatnie 10% prac (704)
  • Efekty (704)
  • Maszyna stanów gry (705)
• Elementy projektu gry (711)
  • Środowiska (712)
  • Fabuła (712)
  • Właściwa gra (714)
  • Uczenie gracza sposobu gry (716)
• Tworzenie edytora map (717)
• Szukanie błędów (719)
  • Problemy z szukaniem błędów w Java2D (722)
  • Rejestrowanie zdarzeń (723)
• Ochrona kodu (725)
• Dystrybucja gry (726)
• Dystrybucja gry za pomocą Java Web Start (728)
  • Pobieranie zasobów z plików .jar (728)
  • Podpisywanie plików .jar (728)
  • Tworzenie pliku JNLP (729)
  • Konfigurowanie serwera WWW (731)
• Dystrybucja gry w postaci kompilacji natywnej (732)
• Aktualizacje i łatki (733)
• Problem obciążenia serwera (733)
• Opinie użytkowników i testy beta (734)
• Zarabianie pieniędzy (736)
• Łączymy wszystko razem (737)
• Podsumowanie (737)

Rozdział 19. Przyszłość (739)

• Ewolucja Javy (739)
  • Java Community Process (740)
  • Bug Parade (740)
• Przyszłość: Java 1.5 "Tiger" (740)
  • Szablony (JSR 14) (741)
  • Wyliczenia (JSR 201) (742)
  • Statyczne importowanie (JSR 201) (743)
  • Poprawiona pętla for (JSR 201) (744)
  • Interfejs API kompilatora (JSR 199) (744)
  • Format transferu sieciowego (JSR 200) (745)
  • Współdzielona maszyna wirtualna (JSR 121) (745)
• Wymagania stawiane platformie Java (746)
  • Potrzebne: więcej opcji dla obsługi myszy i klawiatury (746)
  • Potrzebne: obsługa joysticka (747)
  • Potrzebne: przyspieszane sprzętowo, półprzezroczyste obrazy (747)
  • Potrzebne: dokładniejszy zegar (747)
  • Potrzebne: grafika przyspieszana sprzętowo i tryb pełnoekranowy w systemie Linux (748)
  • Potrzebne: trójwymiarowa grafika przyspieszana sprzętowo, włączona do środowiska Javy (748)
  • Potrzebne: optymalizacja rozkazów SIMD w maszynie HotSpot (749)
  • Pożądane: więcej opcji wygładzania czcionek (750)
  • Pozostałe możliwości (752)
• Nowe urządzenia i Javy Games Profile (JSR 134) (752)
• Podsumowanie (753)

Dodatki (755)

Skorowidz (757)