Poznaj nowoczesne metody tworzenia gier komputerowych
- Wykorzystaj najefektywniejsze techniki oferowane przez C++
- Popraw czytelność kodu i wydajność programów
- Zastosuj wzorce projektowe
Rynek gier komputerowych jest niezwykle wymagający. Gracze stawiają tego rodzaju programom coraz wyższe wymagania, co z kolei przekłada się na konieczność stosowania coraz doskonalszych technik ich tworzenia. Będąc programistą gier komputerowych, na pewno doskonale zdajesz sobie z tego sprawę. Jeśli chcesz, aby kolejna stworzona przez Ciebie gra spełniała oczekiwania nawet najbardziej wybrednych graczy, wykorzystaj język C++. Jego możliwości sprawiają, że jest doskonałym narzędziem do tworzenia gier.
"C++ dla programistów gier. Wydanie II" to przewodnik po języku C++ opisujący go z punktu widzenia programowania specyficznych aplikacji, jakimi są gry. Książka przedstawia najefektywniejsze techniki C++ i metody rozwiązywania problemów, przed którymi stają programiści gier. Czytając ją, dowiesz się, jak zarządzać pamięcią i stosować wzorce projektowe oraz STL. Poznasz możliwości wykorzystania języków skryptowych do usprawnienia procesu tworzenia gry komputerowej. Każde z rozwiązań opatrzone jest przykładem, dzięki czemu łatwo będzie Ci zaimplementować je w swoich pracach.
- Podstawy języka C++
- Korzystanie z szablonów
- Obsługa wyjątków
- Zarządzanie pamięcią
- Poprawa wydajności aplikacji
- Wzorce projektowe
- Biblioteka STL
- Stosowanie języków skryptowych
- Zarządzanie obiektami
- Serializacja
Dołącz do elitarnej grupy programistów gier komputerowych.
Wprowadzenie (13)Część I Elementy C++ (21)
Rozdział 1. Dziedziczenie (23)
- Klasy (23)
- Dziedziczenie (24)
- Polimorfizm i funkcje wirtualne (27)
- Dziedziczyć czy nie dziedziczyć? (30)
- Zasada 1. Dziedziczenie kontra zawieranie (30)
- Zasada 2. Zachowanie kontra dane (31)
- Kiedy stosować dziedziczenie, a kiedy go unikać (31)
- Implementacja dziedziczenia (zaawansowane) (33)
- Analiza kosztowa (zaawansowane) (35)
- Alternatywy (zaawansowane) (38)
- Dziedziczenie a architektura programu (zaawansowane) (39)
- Wnioski (41)
- Zalecana lektura (41)
- Stosowanie dziedziczenia wielobazowego (43)
- Wszystko w jednym (44)
- Wersja z zawieraniem (44)
- Dziedziczenie zwyczajne (46)
- Ratunek w dziedziczeniu wielobazowym (47)
- Problemy dziedziczenia wielobazowego (47)
- Niejednoznaczność (48)
- Topografia (48)
- Architektura programu (51)
- Polimorfizm (51)
- Kiedy stosować dziedziczenie wielobazowe, a kiedy go unikać (53)
- Implementacja dziedziczenia wielobazowego (zaawansowane) (54)
- Analiza kosztowa (zaawansowane) (55)
- Rzutowanie (55)
- Funkcje wirtualne z drugiej (kolejnej) klasy nadrzędnej (57)
- Wnioski (58)
- Zalecana lektura (58)
- Stałość (59)
- Koncepcja stałości (60)
- Stałość a wskaźniki (60)
- Stałość a funkcje (61)
- Stałość a klasy (64)
- Stałe, ale zmienne - słowo mutable (65)
- Słowo porady odnośnie const (66)
- Referencje (67)
- Referencje kontra wskaźniki (67)
- Referencje a funkcje (68)
- Zalety referencji (69)
- Kiedy stosować referencje (71)
- Rzutowanie (72)
- Potrzeba rzutowania (72)
- Rzutowanie w konwencji C++ (73)
- Wnioski (76)
- Zalecana lektura (76)
- W poszukiwaniu kodu uniwersalnego (77)
- Podejście pierwsze: lista wbudowana w klasę (78)
- Podejście drugie: makrodefinicja (79)
- Podejście trzecie: dziedziczenie (80)
- Podejście czwarte: uniwersalna lista wskaźników void (81)
- Szablony (83)
- Szablony klas (83)
- Szablony funkcji (85)
- Powrót do problemu listy - próba z szablonem (85)
- Wady (87)
- Złożoność (87)
- Zależności (87)
- Rozdęcie kodu (88)
- Obsługa szablonów przez kompilator (88)
- Kiedy stosować szablony (88)
- Specjalizacje szablonów (zaawansowane) (89)
- Pełna specjalizacja szablonu (90)
- Częściowa specjalizacja szablonu (91)
- Wnioski (91)
- Zalecana lektura (92)
- Jak sobie radzić z błędami (93)
- Ignorować! (93)
- Stosować kody błędów (94)
- Poddać się (z asercjami)! (95)
- Stosować wywołania setjmp() i longjmp() (95)
- Stosować wyjątki C++ (96)
- Stosowanie wyjątków (97)
- Wprowadzenie (98)
- Zrzucanie wyjątków (98)
- Przechwytywanie wyjątków (100)
- Odporność na wyjątki (103)
- Pozyskiwanie zasobów (104)
- Konstruktory (107)
- Destruktory (109)
- Analiza kosztowa (109)
- Kiedy stosować wyjątki (111)
- Wnioski (112)
- Zalecana lektura (112)
Rozdział 6. Wydajność (115)
- Wydajność i optymalizacje (115)
- W czasie programowania (117)
- Pod koniec programowania (118)
- Rodzaje funkcji (119)
- Funkcje globalne (119)
- Statyczne funkcje klas (120)
- Niewirtualne składowe klas (120)
- Funkcje wirtualne przy dziedziczeniu pojedynczym (121)
- Funkcje wirtualne przy dziedziczeniu wielobazowym (123)
- Rozwijanie funkcji w miejscu wywołania (124)
- Potrzeba rozwijania w funkcji (124)
- Funkcje rozwijane w miejscu wywołania (125)
- Kiedy stosować rozwijanie zamiast wywołania? (127)
- Jeszcze o narzutach wywołań funkcji (128)
- Parametry funkcji (128)
- Wartości zwracane (130)
- Funkcje puste (132)
- Unikanie kopiowania (133)
- Argumenty wywołań (133)
- Obiekty tymczasowe (134)
- Jawność intencji (135)
- Blokowanie kopiowania (135)
- Dopuszczanie kopiowania (136)
- Przeciążanie operatorów (137)
- Konstruktory i destruktory (139)
- Pamięci podręczne i wyrównywanie danych w pamięci (zaawansowane) (143)
- Wzorce odwołań do pamięci (144)
- Rozmiar obiektów (145)
- Rozmieszczanie składowych w obiektach (146)
- Wyrównanie pamięci (146)
- Wnioski (147)
- Zalecana lektura (148)
- Stos (149)
- Sterta (150)
- Wydajność przydziału (151)
- Fragmentacja pamięci (152)
- Inne problemy (154)
- Przydziały statyczne (155)
- Zalety i wady przydziału statycznego (156)
- Kiedy korzystać z przydziałów statycznych (157)
- Przydziały dynamiczne (158)
- Łańcuch wywołań (158)
- Globalne operatory new i delete (159)
- Operatory new i delete dla klas (161)
- Własny menedżer pamięci (163)
- Kontrola błędów (163)
- Przeglądanie stert (166)
- Zakładki i wycieki (166)
- Sterty hierarchiczne (167)
- Inne rodzaje przydziałów (169)
- Narzut mechanizmu zarządzania pamięcią (170)
- Pule pamięci (171)
- Implementacja (172)
- Podłączanie puli do sterty (175)
- Pule uniwersalne (176)
- W nagłych wypadkach... (177)
- Wnioski (178)
- Zalecana lektura (179)
- Czym są wzorce projektowe? (181)
- Wzorzec Singleton (183)
- Przykład: menedżer plików (183)
- Implementacja Singletona (184)
- Wzorzec Façade (185)
- Fasada dla systemu "w budowie" (188)
- Fasada dla przeróbek (189)
- Wzorzec Observer (190)
- Wzorzec Visitor (195)
- Wnioski (199)
- Zalecana lektura (199)
- Przegląd STL (201)
- Korzystać czy nie korzystać? (203)
- Wykorzystanie gotowego kodu (203)
- Wydajność (204)
- Wady (205)
- Kontenery sekwencyjne (206)
- Kontener vector (206)
- Kontener deque (211)
- Kontener list (214)
- Kontenery asocjacyjne (217)
- Kontenery set i multiset (218)
- Kontenery map i multimap (222)
- Kontenery haszowane (226)
- Adaptory kontenerów (230)
- Stos (231)
- Kolejka (231)
- Kolejka priorytetowa (232)
- Wnioski (233)
- Zalecana lektura (235)
- Obiekty funkcyjne (funktory) (237)
- Wskaźniki funkcji (237)
- Funktory (238)
- Adaptory funktorów (240)
- Algorytmy (241)
- Algorytmy niemodyfikujące (242)
- Algorytmy modyfikujące (245)
- Algorytmy sortujące (248)
- Uogólnione algorytmy numeryczne (249)
- Ciągi znaków (250)
- Ciągle bez ciągów (250)
- Klasa string (252)
- Wydajność (254)
- Pamięć (255)
- Alternatywy (256)
- Alokatory (zaawansowane) (257)
- Kiedy STL nie wystarcza (zaawansowane) (260)
- Wnioski (262)
- Zalecana lektura (262)
- Grafy - studium przypadku (265)
- Powtórka z grafów (265)
- Ogólniej o grafie (267)
- W kwestii kosztów (267)
- Koszt przebycia krawędzi a jakość rozgrywki (268)
- Grafy w C++ (269)
- Zaprząc grafy do pracy (271)
- "Inteligencja" grafów (276)
- Życie na krawędzi (276)
- Aktualizacja, wracamy do C++ (279)
- Implementacja wyznaczania trasy (285)
- A może A* (zaawansowane) (293)
- Inne zastosowania grafów (294)
- Optymalizacja przejść w interfejsie użytkownika (296)
- Brakujące ścieżki powrotne (298)
- Zagubione plansze menu (298)
- Wnioski (299)
- Zalecana lektura (299)
Rozdział 12. Interfejsy abstrakcyjne (303)
- Interfejsy abstrakcyjne (303)
- Implementacja interfejsów w C++ (305)
- Interfejsy abstrakcyjne w roli bariery (306)
- Nagłówki i wytwórnie (308)
- Z życia (310)
- Interfejsy abstrakcyjne w roli charakterystyk klas (312)
- Implementacje (313)
- Pytanie o interfejs (315)
- Rozszerzanie gry (317)
- Nie wszystko złoto... (319)
- Wnioski (320)
- Zalecana lektura (321)
- Po co komu wtyczki (323)
- Wtyczki do cudzych programów (324)
- Wtyczki do własnych programów (325)
- Architektura wtyczek (326)
- Interfejs wtyczek (326)
- Tworzenie konkretnych wtyczek (327)
- Obsługa różnych rodzajów wtyczek (328)
- Ładowanie wtyczek (329)
- Menedżer wtyczek (331)
- Komunikacja dwukierunkowa (333)
- Żeby miało ręce i nogi... (335)
- Wtyczki w praktyce (335)
- Stosowanie wtyczek (336)
- Wady (336)
- Inne platformy (337)
- Wnioski (338)
- Zalecana lektura (338)
- Po co jeszcze jeden język, i to skryptowy? (339)
- Złe wieści... (340)
- I wieści dobre (341)
- Rozważania o architekturze (344)
- Engine kontra gameplay (345)
- Zintegrowany interpreter skryptów - nie tylko w sterowaniu rozgrywką (349)
- Konsola (349)
- Interaktywne sesje diagnostyczne (350)
- Szybkie prototypowanie (352)
- Automatyzacja testów (353)
- Wnioski (355)
- Zalecana lektura (356)
- Lua (356)
- Python (357)
- GameMonkey Script (357)
- AngelScript (358)
- Praca bez RTTI (359)
- Używanie i nadużywanie RTTI (361)
- Standardowe RTTI w C++ (363)
- Operator dynamic_cast (363)
- Operator typeid (365)
- Analiza RTTI w wydaniu C++ (366)
- Własny system RTTI (368)
- Najprostsze rozwiązanie (368)
- Z obsługą dziedziczenia pojedynczego (372)
- Z obsługą dziedziczenia wielobazowego (375)
- Wnioski (378)
- Zalecana lektura (378)
- Tworzenie obiektów (379)
- Kiedy new nie wystarcza (380)
- Wielka selekcja (381)
- Wytwórnie obiektów (382)
- Prosta wytwórnia (382)
- Wytwórnia rozproszona (383)
- Jawne rejestrowanie obiektów wytwórczych (384)
- Niejawne rejestrowanie obiektów wytwórczych (385)
- Identyfikatory typów obiektów (387)
- Od szablonu (388)
- Obiekty współużytkowane (389)
- Bez wspólnych obiektów (390)
- Ignorowanie problemu (391)
- Niech się właściciel martwi (392)
- Zliczanie odwołań (393)
- Uchwyty (396)
- Inteligentne wskaźniki (398)
- Wnioski (401)
- Zalecana lektura (402)
- Przegląd zagadnień dotyczących utrwalania jednostek gry (405)
- Jednostki kontra zasoby (406)
- Najprostsze rozwiązanie, które nie zadziała (406)
- Czego potrzebujemy (407)
- Implementacja utrwalania jednostek gry (409)
- Strumienie (409)
- Zapisywanie (412)
- Wczytywanie (416)
- Wespół w zespół (419)
- Wnioski (420)
- Zalecana lektura (421)
- Struktura logiczna a struktura fizyczna (423)
- Klasy i pliki (425)
- Pliki nagłówkowe (426)
- Co ma się znaleźć w pliku nagłówkowym? (426)
- Bariery włączania (427)
- Dyrektywy #include w plikach implementacji (430)
- Dyrektywy #include w plikach nagłówkowych (432)
- Wstępnie kompilowane pliki nagłówkowe (434)
- Wzorzec implementacji prywatnej (437)
- Biblioteki (440)
- Konfiguracje (443)
- Konfiguracja diagnostyczna (444)
- Konfiguracja dystrybucyjna (444)
- Konfiguracja diagnostyczna zoptymalizowana (445)
- Wnioski (445)
- Zalecana lektura (446)
- Stosowanie asercji (447)
- Kiedy stosować asercje (448)
- Kiedy nie stosować asercji (450)
- Własne asercje (451)
- Co powinno się znaleźć w ostatecznej wersji (452)
- Własna przykładowa implementacja asercji (454)
- Zawsze świeżo (455)
- Wycieki pamięci (456)
- Fragmentacja pamięci (456)
- Dryf zegara (456)
- Kumulacja błędu (457)
- Co robić? (457)
- Postępowanie ze "złymi" danymi (458)
- Wykrywać asercjami (459)
- Radzić sobie samemu (459)
- Kompromis (461)
- Wnioski (463)
- Zalecana lektura (463)