reklama - zainteresowany?

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 - Helion


ebook
Autor: Rob Miles
Tytuł oryginału: Microsoft XNA Game Studio 4.0: Learn Programming Now!: How to program for Windows Phone 7, Xbox 360, Zune devices, and more
Tłumaczenie: Mikołaj Szczepaniak (wstęp, rozdz. 1 - 3, 10 - 16); Jacek Kowolik (rozdz. 4 - 9, 17 - 19)
ISBN: 978-83-246-7175-5
stron: 528, Format: ebook
Data wydania: 2013-02-25
Księgarnia: Helion

Cena książki: 44,50 zł (poprzednio: 89,00 zł)
Oszczędzasz: 50% (-44,50 zł)

Dodaj do koszyka

Tagi: Programowanie gier

Każdy pasjonat gier komputerowych zadawał sobie czasem pytania typu: "Niesamowite, jak oni to zrobili?" albo "Jak można uzyskać taki efekt?". A co się dzieje, jeśli to pytanie przychodzi do głowy programiście? Jego następną myślą zwykle jest: "Muszę spróbować sam to zrobić!". Na co czekasz? Dziś już nic nie stoi na przeszkodzie! Odkąd Microsoft udostępnił framework XNA, każdy może wymyślić i stworzyć swoją własną profesjonalną grę komputerową, uruchomić ją na prawdziwej konsoli, a nawet wprowadzić na rynek dzięki usłudze Xbox Live lub Windows Phone Marketplace.

Jeśli zawsze marzyłeś o profesjonalnym programowaniu gier, ale nie do końca wiedziałeś, jak się za to zabrać, oto książka, która wszystko zmieni! Ten podręcznik będzie dla Ciebie doskonałym przewodnikiem, prowadzącym od opanowania podstaw frameworku XNA, przez zasady programowania w użytecznym języku C#, aż po tworzenie własnych gier. Przejdziesz niezwykłą drogę: na jej początku czeka Cię instalacja i przygotowanie środowiska programistycznego, potem projektowanie realistycznej grafiki gry i jej ciekawe udźwiękowienie, a uwieńczeniem Twoich działań będzie stworzenie profesjonalnych projektów dla konsoli Xbox 360®, telefonów z systemem Windows® Phone 7 czy komputerów PC. Co ważne, nie musisz być zaawansowanym i doświadczonym programistą. Wszystko, czego będziesz potrzebował do realizacji tej misji, znajdziesz w tej książce!

Nauczysz się m.in.:

  • pisać kod tworzący zachowania w grze i sterujący nimi
  • projektować wygląd gry - grafikę, czcionki, kolory, oświetlenie i efekty trójwymiarowe
  • budować obiekty gry, tzw. sprajty
  • nagrywać i odtwarzać dźwięki
  • przetwarzać dane wejściowe uzyskiwane z padów i klawiatur
  • korzystać z ekranu dotykowego i akcelerometru w systemie Windows Phone
  • dodawać stopery, systemy punktacji, elementy zagrażające graczowi i postęp w rozgrywce
  • tworzyć gry wieloosobowe i sieciowe

Opanuj sztukę programowania gier i zmieniaj własne pomysły w ekscytującą rzeczywistość!

Dodaj do koszyka

 

Osoby które kupowały "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", wybierały także:

  • Tworzenie gier komputerowych. Kompendium producenta
  • Unity. Tworzenie gier mobilnych

Dodaj do koszyka

Spis treści

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 eBook -- spis treści

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)

Dodaj do koszyka

Code, Publish & WebDesing by CATALIST.com.pl



(c) 2005-2020 CATALIST agencja interaktywna, znaki firmowe należą do wydawnictwa Helion S.A.