Microsoft XNA Game Studio 4.0. Projektuj i buduj własne gry dla konsoli Xbox 360, urządzeń z systemem Windows Phone 7 i własnego PC

Wstęp (15)

Część I: Wprowadzenie

1. Komputery, C#, XNA i Ty (19)

• Wprowadzenie (19)
  
  • Nauka programowania (19)
  • Jak zostać świetnym programistą (20)
• Jak działa ta książka (21)
  
• Język C# i framework XNA (21)
  
• Do dzieła (22)
  
  • Instalacja środowiska programowania i frameworku XNA (22)
  • Konfiguracja komputera PC pod kątem uruchamiania gier XNA (23)
  • Konfiguracja konsoli Xbox 360 pod kątem uruchamiania gier XNA (24)
  • Konfiguracja systemu Windows Phone pod kątem uruchamiania gier XNA (26)
• Pisanie pierwszego programu (28)
  
  • Tworzenie pierwszego projektu (28)
  • Uruchamianie pierwszego programu (31)
  • Zatrzymywanie programu (33)
  • Przechowywanie gier w konsoli Xbox 360 lub urządzeniu z systemem Windows Phone (34)
  • Uruchamianie tej samej gry XNA na różnych urządzeniach (34)
• Podsumowanie (37)
  
• Przegląd rozdziału w pytaniach (37)

2. Programy, dane i ładne kolory (39)

• Wprowadzenie (39)
  
• Tworzenie programu gry (40)
  
  • Wyrażenia w metodzie Draw (41)
• Praca z kolorami (43)
  
  • Przechowywanie wartości kolorów (43)
  • Ustawianie wartości koloru (44)
• Kontrolowanie koloru (45)
  
  • Gry i klasy (46)
  • Klasy jako biura (48)
  • Dane świata gry (49)
  • Przechowywanie danych w pamięci komputera (51)
  • Rysowanie z wykorzystaniem zmiennych intensywności barw (52)
  • Aktualizowanie kolorów (53)
  • Przepełnienie pamięci i wartości danych (55)
  • Pełnowartościowa wielokolorowa lampa (56)
  • Podejmowanie decyzji w programie (57)
  • Gotowa gra w wielokolorową lampę (61)
  • Znajdowanie błędów w programie (63)
• Podsumowanie (65)
  
• Przegląd rozdziału w pytaniach (65)

3. Pobieranie danych wejściowych od gracza (67)

• Wprowadzenie (67)
  
• Odczytywanie stanu pada (68)
  
  • Pady i klasy (68)
  • Znajdowanie pada (70)
  • Testowanie statusu pada (72)
• Stosowanie klawiatury (73)
  
  • Zatrzymywanie gry za pomocą klawisza Escape (75)
  • Jednoczesne używanie pada i klawiatury (75)
• Dodawanie wibracji (77)
  
  • Sterowanie wibracjami pada (77)
  • Testowanie wartości intensywności (78)
• Błędy w programie (83)
  
• Podsumowanie (85)
  
• Przegląd rozdziału w pytaniach (85)

Część II: Obrazy, dźwięk i tekst

4. Wyświetlanie obrazów (89)

• Wprowadzenie (89)
  
• Zasoby i zawartość (90)
  
  • Dodawanie obrazów (90)
  • Zarządzanie zawartością z użyciem XNA (92)
  • Praca z zawartością za pomocą XNA Game Studio (92)
  • Rozwiązania i projekty w XNA Game Studio (92)
  • Dodawanie zawartości do projektu (94)
• Korzystanie z zasobów w programie gry (97)
  
  • Ładowanie tekstur w XNA (97)
  • Pozycjonowanie sprajtu na ekranie (101)
  • Wyświetlanie sprajtu za pomocą klasy SpriteBatch (103)
  • Wypełnianie ekranu (105)
  • Intellisense (106)
• Podsumowanie (108)
  
• Przegląd rozdziału w pytaniach (108)

5. Wyświetlanie tekstu (111)

• Wprowadzenie (111)
  
• Komputery i tekst (111)
  
  • Tekst jako zasób (112)
  • Tworzenie projektu zegara w XNA (112)
  • Dodawanie czcionki do zasobów (112)
  • Format plików XML (115)
  • Ładowanie czcionki (115)
  • Wyświetlanie z użyciem czcionki (116)
  • Zmiana właściwości czcionki (118)
• Uzyskiwanie daty i czasu (119)
  
• Tworzenie ładniejszego zegara z tekstem 3D (122)
  
  • Wielokrotne wyświetlanie łańcuchów tekstu (122)
  • Powtarzanie instrukcji z użyciem pętli for (124)
  • Inne konstrukcje pętli (126)
  • Zabawa z pętlą for (126)
• Tworzenie iluzji trójwymiaru (128)
  
  • Tworzenie cieni z użyciem kolorów przezroczystych (128)
  • Wyświetlanie obrazów z użyciem przezroczystości (130)
• Podsumowanie (131)
  
• Przegląd rozdziału w pytaniach (131)

6. Tworzenie gry dla wielu graczy (133)

• Wprowadzenie (133)
  
  • Tworzenie gry z wciskaniem przycisków (133)
  • Dane w grze ButtonBash (134)
  • Rozpoczynanie gry ButtonBash (134)
  • Wyświetlanie wartości licznika wciśnięć przycisku (135)
  • Zliczanie wciśnięć przycisku (135)
  • Wykrywanie zmian położenia przycisku (136)
  • Wykrywanie poziomu i zbocza (137)
  • Konstruowanie kompletnej gry (138)
  • Projektowanie kodu (140)
  • Dodawanie kodu testowego (140)
• Podsumowanie (143)
  
• Przegląd rozdziału w pytaniach (143)

7. Odtwarzanie dźwięków (145)

• Dodawanie dźwięku (145)
  
  • Tworzenie projektu Drum Pad (145)
  • Nagrywanie dźwięków w programie Audacity (146)
  • Przechowywanie dźwięków w projekcie (147)
  • Stosowanie dźwięków w programie w XNA (149)
  • Odtwarzanie muzyki w tle (151)
  • Ciągłe odtwarzanie dźwięku (151)
  • Kontrola wartości null w referencjach (155)
  • XACT audio tool (156)
  • Odtwarzanie muzyki za pomocą klasy MediaPlayer (156)
• Podsumowanie (158)
  
• Przegląd rozdziału w pytaniach (158)

8. Pomiar czasu (159)

• Tworzenie kolejnej gry (159)
  
  • Błąd w pomiarze czasu reakcji (162)
• Ustalanie zwycięzcy za pomocą tablic (164)
  
  • Tworzenie tablicy (165)
  • Korzystanie z danych w tablicy (165)
  • Przeglądanie tablicy (167)
  • Zastosowanie tablicy jako słownika (168)
  • Wyświetlanie zwycięzcy (170)
• Podsumowanie (172)
  
• Przegląd rozdziału w pytaniach (172)

9. Wczytywanie tekstu wejściowego (173)

• Używanie klawiatury w XNA (173)
  
  • Tworzenie projektu Tablica ogłoszeń (173)
  • Rejestrowanie wciśnięć klawiszy (174)
  • Wykrywanie momentu wciśnięcia klawisza (175)
  • Typ Keys (175)
  • Typy wyliczeniowe (176)
• Praca z tablicami, obiektami i referencjami (177)
  
  • Wartości i referencje (177)
  • Tablice jako biura (178)
  • Przywitaj się z procesem odzyskiwania pamięci (179)
  • Używanie referencji i wartości (180)
  • Do czego służą referencje i wartości? (181)
  • Referencje i metoda GetPressedKeys (182)
• Wyświetlanie klawiszy (182)
  
  • Wykrywanie wciśnięć klawiszy (183)
  • Dekodowanie znaków na klawiszach (188)
  • Używanie klawiszy Shift (189)
  • A co z polskimi znakami? (190)
  • Edycja tekstu (192)
• Podsumowanie (193)
  
• Przegląd rozdziału w pytaniach (194)

Część III: Pisanie poprawnych gier

10. Używanie metod języka C# do rozwiązywania problemów (197)

• Wprowadzenie (197)
  
• Zabawa z obrazami (197)
  
  • Przybliżanie obrazu (198)
• Tworzenie efektu oddalania (200)
  
  • Aktualizowanie prostokąta rysowania (200)
  • Tworzenie metody obliczającej wartości procentowe (203)
  • Stosowanie słowa void (206)
  • Diagnozowanie programów języka C# (210)
  • Trafianie w punkt zatrzymania (212)
  • Używanie liczb zmiennoprzecinkowych w języku C# (214)
  • Kompilator i typy danych języka C# (215)
  • Kompilatory i rzutowanie (217)
  • Typy wyrażeń (218)
  • Zatrzymywanie oddalania (220)
  • Oddalanie ze środka zdjęcia (220)
• Podsumowanie (224)
  
• Przegląd rozdziału w pytaniach (224)

11. Gra jako program języka C# (227)

• Wprowadzenie (227)
  
• Tworzenie grafiki gry (228)
  
• Projekty, zasoby i klasy (229)
  
  • Rozwiązania i projekty środowiska XNA Game Studio (229)
  • Plik Program.cs (232)
  • Zmiana nazwy klasy Game1 (238)
• Tworzenie obiektów gry (240)
  
  • Sprajty w grze (240)
  • Zarządzanie rozmiarem sprajtów gry (240)
  • Wprawianie sprajtów w ruch (244)
  • Odbijanie sera (246)
  • Obsługa nadmiarowości ekranu (246)
• Podsumowanie (248)
  
• Przegląd rozdziału w pytaniach (249)

12. Gry, obiekty i stan (251)

• Wprowadzenie (251)
  
• Dodanie chleba do gry (251)
  
  • Stosowanie struktury do przechowywania informacji o sprajcie (252)
  • Sterowanie ruchem za pomocą gałki pada (254)
  • Doskonalenie programów za pomocą metod (256)
  • Obsługa kolizji (259)
  • Odbijanie sera od chleba (260)
  • Dziwne zachowanie mechanizmu odbijania (260)
  • Dziwne zachowanie krawędzi (261)
• Dodanie pomidorowych celów (264)
  
  • Kolizje z pomidorami (267)
• Podsumowanie (269)
  
• Przegląd rozdziału w pytaniach (270)

13. Tworzenie kompletnej gry (271)

• Wprowadzenie (271)
  
• Tworzenie skończonej gry (271)
  
  • Dodanie punktacji do gry (271)
  • Dodanie elementu ryzyka (273)
  • Dodanie postępu w grze (275)
• Doskonalenie projektu kodu (278)
  
  • Refaktoryzacja poprzez tworzenie metod dla istniejącego kodu (279)
  • Refaktoryzacja poprzez zmianę identyfikatorów (280)
  • Tworzenie obszarów kodu (282)
  • Tworzenie przydatnych komentarzy (283)
• Dodanie tła (285)
  
• Dodanie ekranu tytułowego (286)
  
  • Gry i stan (287)
  • Stosowanie wartości stanu (287)
  • Budowa maszyny stanów (288)
• Podsumowanie (291)
  
• Przegląd rozdziału w pytaniach (291)

14. Klasy, obiekty i gry (293)

• Wprowadzenie (293)
  
• Projektowanie przy użyciu obiektów (293)
  
  • Kurs odświeżający wiedzę o obiektach (294)
  • Spójność i obiekty (295)
  • Związki pomiędzy obiektami (298)
  • Projektowanie interakcji pomiędzy obiektami (301)
  • Obiekty kontenerów (303)
  • Obiekty tła i ekranu tytułowego (305)
• Klasy i struktury (306)
  
  • Tworzenie i stosowanie struktury (306)
  • Tworzenie i stosowanie egzemplarza klasy (307)
• Referencje (309)
  
  • Wiele referencji do jednego egzemplarza (309)
  • Brak referencji do egzemplarza (310)
  • Po co w ogóle stosować referencje? (311)
• Typy wartościowe i referencyjne (311)
  
  • Czy obiekty w naszej grze powinny mieć postać klas, czy też struktur? (312)
• Tworzenie hierarchii klas sprajtów (314)
  
  • Klasa BaseSprite (314)
  • Rozszerzenie klasy BaseSprite w celu utworzenia klasy TitleSprite (316)
  • Budowa hierarchii klas (317)
• Dodanie morderczej papryki (318)
  
  • Tworzenie klasy DeadlySprite (318)
• Podsumowanie (323)
  
• Przegląd rozdziału w pytaniach (323)

15. Tworzenie komponentów gry (325)

• Wprowadzenie (325)
  
• Obiekty i abstrakcja (325)
  
  • Tworzenie klasy abstrakcyjnej w języku C# (326)
  • Rozszerzanie klasy abstrakcyjnej (327)
  • Projektowanie przy użyciu klas abstrakcyjnych (328)
  • Referencje do abstrakcyjnych klas macierzystych (329)
• Konstruowanie egzemplarzy klas (330)
  
  • Konstruktory w strukturach (332)
  • Konstruktory w hierarchii klas (333)
• Dodanie stu zabójczych mandarynek (335)
  
  • Tworzenie klasy KillerSprite (335)
  • Ustawianie położenia sprajtów KillerSprite za pomocą liczb losowych (336)
  • Stosowanie list referencji (339)
• Dodanie sztucznej inteligencji (342)
  
  • Ściganie pałki chlebowej (343)
• Dodanie dźwięków w grze (347)
  
• Od obiektów do komponentów (350)
  
  • Interfejsy języka C# (351)
  • Tworzenie interfejsu (352)
  • Implementowanie interfejsu (353)
  • Referencje do interfejsów (353)
  • Łączenie chleba, sera i pomidorów (354)
  • Projektowanie przy użyciu interfejsów (354)
• Podsumowanie (355)
  
• Przegląd rozdziału w pytaniach (355)

16. Tworzenie gier sieciowych dla wielu graczy (357)

• Wprowadzenie (357)
  
• Sieci i komputery (357)
  
  • Wszystko zaczyna się od sygnału (358)
  • Konstruowanie pakietów (358)
  • Adresowanie komunikatów (358)
  • Trasowanie (359)
  • Połączenia i datagramy (360)
  • Sieci i protokoły (361)
• Usługa Xbox Live (362)
  
  • Karty graczy i usługa Xbox Live (362)
  • Technologia System Link i framework XNA (363)
• Ping-pong chleba i sera (363)
  
  • Zarządzanie profilami graczy we frameworku XNA (364)
  • Sprawdzanie logowania gracza na potrzeby gry sieciowej (368)
  • Tworzenie lobby gry (369)
  • Gry sieciowe i stan (369)
  • Rozgrywka (377)
  • Kompletna gra (382)
• Podsumowanie (382)
  
• Przegląd rozdziału w pytaniach (383)

Część IV: Tworzenie mobilnych gier dla systemu Windows Phone 7 za pomocą XNA (385)

17. Gry sterowane ruchem telefonu (387)

• Wprowadzenie (387)
  
• Akcelerometr (387)
  
  • Do czego tak naprawdę służy akcelerometr? (387)
• Przyspieszenie z punktu widzenia fizyki (388)
  
  • Interpretowanie odczytów z akcelerometru (390)
• Tworzenie gry Cheese Lander sterowanej przechylaniem (391)
  
  • Obiekty świata gry Cheese Lander (391)
  • Dostęp do klasy Accelerometer z programu w XNA (392)
  • Używanie klasy Accelerometer w grze dla środowiska XNA (395)
  • Uruchamianie akcelerometru (397)
  • Wykorzystanie odczytów z akcelerometru w programie gry (398)
  • Poprawianie przebiegu gry z wykorzystaniem praw fizyki (398)
  • Wyrażanie ruchu za pomocą wektorów (400)
  • Dodawanie tarcia (401)
  • Sterowanie dźwiękiem za pomocą wektorów (402)
  • Wykrywanie potrząsania (403)
  • Krótka dygresja na temat wątków i synchronizacji (403)
• Podsumowanie (405)
  
• Przegląd rozdziału w pytaniach (406)

18. Obsługa sterowania dotykiem (407)

• Wprowadzenie (407)
  
• Ekran dotykowy w telefonach z systemem Windows Phone (407)
  
  • Pobieranie wejścia dotykowego (408)
• Tworzenie przycisku alarmowego (408)
  
  • Odczytywanie zdarzeń z wejścia dotykowego (409)
  • Typy obiektów TouchLocation (409)
  • Obsługa miejsca dotknięcia (411)
• Tworzenie dotykowej perkusji (412)
  
  • Tworzenie klasy SoundPad dla każdego z dźwięków perkusji (412)
  • Przechowywanie w programie wartości typu soundPad (413)
  • Wyświetlanie przycisków (414)
  • Odświeżanie stanu przycisków (415)
  • Podświetlanie przycisków (416)
• Tworzenie "ślizganej" gry planszowej (418)
  
  • Klasa PuckSprite (419)
  • Odświeżanie stanu nieruchomego krążka (420)
  • Przemieszczanie krążka po ekranie (421)
  • Krążek poruszający się po planszy (422)
  • Emulatory i prawdziwe urządzenia (424)
• Podsumowanie (425)
  
• Przegląd rozdziału w pytaniach (425)

19. Konstruowanie mobilnych gier (427)

• Wprowadzenie (427)
  
• Telefon z systemem Windows Phone (427)
  
  • Windows Phone Marketplace (428)
• Wydłużanie czasu życia baterii telefonu podczas działania gier w XNA (428)
  
  • Ustawianie częstotliwości odświeżania w grze (428)
• Obsługa zmian orientacji telefonu (429)
  
  • Wybór orientacji z programu gry w XNA (430)
  • Otrzymywanie komunikatu o zmianie orientacji (430)
• Używanie określonego rozmiaru ekranu w grach dla systemu Windows Phone (432)
  
• Ukrywanie paska stanu systemu Windows Phone (432)
  
• Wyłączanie blokowania ekranu podczas gry (433)
  
• Tworzenie maszyny stanów dla telefonu (434)
  
  • Gry i stany (434)
  • Tworzenie prostej maszyny stanów dla gry (435)
  • Tworzenie bardziej skomplikowanych maszyn stanów (437)
• Obsługa przychodzących połączeń telefonicznych (439)
  
  • Wykrywanie połączeń telefonicznych (441)
• Gra jako aplikacja w systemie Windows Phone (442)
  
  • Przyciski Back i Start systemu Windows Phone (443)
  • Uruchamianie nowych programów za pomocą przycisku Start (445)
  • Korzystanie z izolowanych obszarów przechowywania do zapisywania stanu gry (446)
• Dostarczanie naszych gier do usługi Marketplace (453)
  
  • Usługa Windows Phone Marketplace (453)
  • Rejestracja w serwisie App Hub (454)
  • Używane urządzenia z systemem Windows Phone (454)
  • Tworzenie gier na sprzedaż (454)
• Podsumowanie (455)
  
• Przegląd rozdziału w pytaniach (455)

Dodatki (457)

Odpowiedzi na pytania do rozdziałów (459)

Słownik pojęć (483)

Skorowidz (511)

O autorze (525)