E-book details

Unity w akcji

Unity w akcji

Joe Hocking

Ebook

Unity w akcji

Warunkiem zbudowania dobrej gry jest staranne opracowanie jej mechaniki, czyli poszczególnych akcji i systemu tych akcji. Gry, które odniosły największy sukces, charakteryzują się innowacyjną i interesującą mechaniką. Niemniej nawet jeśli już opracowałeś projekt gry, łącznie z jej mechaniką, grafiką i dźwiękiem, potrzebujesz bardzo dobrego narzędzia, aby utworzyć grę, która osiągnie sukces i zyska popularność. Takim narzędziem jest Unity — zintegrowane środowisko do tworzenia trójwymiarowych i dwuwymiarowych gier komputerowych oraz innych materiałów interaktywnych.

Niniejsza książka jest przeznaczona dla osób, które osiągnęły biegłość w programowaniu i teraz chcą pisać gry za pomocą Unity. Wyczerpująco przedstawiono kolejne kroki podejmowane podczas pisania gry w Unity. Nauka została oparta na przykładach: w książce znalazło się kilka projektów różnych gier. Opisano również metody wdrażania gier na różnych platformach, między innymi internetowej i mobilnej — Unity jest środowiskiem w pełni niezależnym od platformy sprzętowej. Nie zabrakło również informacji o narzędziach przydatnych do projektowania grafiki 3D oraz o innych zasobach, dzięki którym praca programisty staje się efektywna i bardzo satysfakcjonująca!

W tej książce omówiono między innymi:
- programowanie poruszania się postaci po świecie 3D, raycasting i sztuczną inteligencję
- zasoby takie jak modele i tekstury: tworzenie i import
- GUI oraz implementację interaktywnych urządzeń i elementów w grze
- obsługę krótszych i dłuższych ścieżek dźwiękowych
- komunikację z internetem oraz obsługę różnych platform sprzętowych

Unity — i oto stworzysz zadziwiający świat dla swoich graczy!


Joseph Hocking jest inżynierem oprogramowania. Specjalizuje się w tworzeniu interaktywnych aplikacji. Pracuje w firmie Synapse Games, gdzie zajmuje się programowaniem gier internetowych i mobilnych, takich jak ostatnio wydana Tyrant Unleashed. Jest również wykładowcą w Columbia College Chicago. Mieszka w Chicago.

Przedmowa (11)

Wprowadzenie (13)

Podziękowania (15)

O książce (17)

CZĘŚĆ I. PIERWSZE KROKI (21)

Rozdział 1. Poznajemy Unity (23)

  • 1.1. Dlaczego Unity jest doskonałym wyborem? (24)
    • 1.1.1. Mocne i słabe strony Unity (24)
    • 1.1.2. Wady, których należy być świadomym (27)
    • 1.1.3. Przykłady gier utworzonych za pomocą Unity (28)
  • 1.2. Jak używać Unity? (30)
    • 1.2.1. Widoki Scene i Game oraz pasek narzędzi (31)
    • 1.2.2. Użycie klawiatury i myszy (33)
    • 1.2.3. Panele Hierarchy i Inspector (34)
    • 1.2.4. Panele Project i Console (35)
  • 1.3. Rozpoczęcie programowania w Unity (35)
    • 1.3.1. Uruchamianie kodu w Unity - komponent skryptu (37)
    • 1.3.2. Użycie MonoDevelop, czyli niezależnego od platformy środowiska IDE (38)
    • 1.3.3. Wyświetlanie informacji w konsoli (40)
  • 1.4. Podsumowanie (42)

Rozdział 2. Budowa demo pokazującego przestrzeń 3D (43)

  • 2.1. Zanim przystąpisz do pracy... (44)
    • 2.1.1. Planowanie projektu (44)
    • 2.1.2. Poznajemy układ współrzędnych 3D (45)
  • 2.2. Rozpoczęcie projektu - umieszczenie obiektów na scenie (47)
    • 2.2.1. Sceneria - podłoże, ściany zewnętrzne i wewnętrzne (48)
    • 2.2.2. Światła i kamera (50)
    • 2.2.3. Punkt widzenia i kolizje gracza (52)
  • 2.3. Poruszanie obiektami - skrypt pozwalający na zastosowanie transformacji (53)
    • 2.3.1. Diagram pokazujący sposób programowania ruchu (53)
    • 2.3.2. Utworzenie kodu źródłowego implementującego ruch (54)
    • 2.3.3. Współrzędne lokalne kontra globalne (56)
  • 2.4. Skrypt MouseLook pozwalający na rozglądanie się (57)
    • 2.4.1. Rotacja pozioma na podstawie ruchu myszy (58)
    • 2.4.2. Rotacja pionowa z ograniczeniami (59)
    • 2.4.3. Jednoczesna rotacja w poziomie i w pionie (61)
  • 2.5. Komponent danych wejściowych klawiatury - kontrolki pierwszej osoby (64)
    • 2.5.1. Reakcja na naciśnięcie klawisza (64)
    • 2.5.2. Ustawienie współczynnika ruchu niezależnie od szybkości komputera (65)
    • 2.5.3. Komponent Character Controller i wykrywanie kolizji (66)
    • 2.5.4. Dostosowanie komponentów do ruchu po ziemi, a nie do lotu (68)
  • 2.6. Podsumowanie (70)

Rozdział 3. Dodanie nieprzyjaciół i pocisków do gry 3D (71)

  • 3.1. Oddawanie strzałów i raycasting (72)
    • 3.1.1. Czym jest raycasting? (73)
    • 3.1.2. Użycie metody ScreenPointToRay() (73)
    • 3.1.3. Dodanie graficznych wskaźników celownika i miejsca trafienia pocisku (76)
  • 3.2. Skrypt obsługujący reaktywnych nieprzyjaciół (79)
    • 3.2.1. Ustalenie, co zostało trafione (79)
    • 3.2.2. Poinformowanie celu o jego trafieniu (80)
  • 3.3. Podstawy sztucznej inteligencji (82)
    • 3.3.1. Diagram pokazujący sposób działania podstawowej sztucznej inteligencji (82)
    • 3.3.2. Dostrzeżenie przeszkód za pomocą promienia światła (83)
    • 3.3.3. Monitorowanie stanu postaci (85)
  • 3.4. Tworzenie prefabrykatu nieprzyjaciela (87)
    • 3.4.1. Czym jest prefabrykat? (87)
    • 3.4.2. Utworzenie prefabrykatu nieprzyjaciela (87)
    • 3.4.3. Utworzenie obiektu na podstawie niewidzialnego obiektu wraz z dołączonym skryptem SceneController (88)
  • 3.5. Oddawanie strzałów przez tworzenie obiektów (90)
    • 3.5.1. Utworzenie prefabrykatu pocisku (90)
    • 3.5.2. Strzelanie pociskiem i trafianie w cel (92)
    • 3.5.3. Uszkodzenie gracza (95)
  • 3.6. Podsumowanie (96)

Rozdział 4. Przygotowanie grafiki dla gry (97)

  • 4.1. Poznajemy zasoby graficzne (97)
  • 4.2. Utworzenie prostej scenerii 3D - whiteboxing (100)
    • 4.2.1. Poznajemy whiteboxing (101)
    • 4.2.2. Przygotowanie planu podłoża dla poziomu (102)
    • 4.2.3. Ułożenie kształtów na podstawie planu (102)
  • 4.3. Teksturowanie sceny za pomocą obrazów 2D (103)
    • 4.3.1. Wybór formatu pliku (104)
    • 4.3.2. Import pliku graficznego (106)
    • 4.3.3. Użycie obrazu tekstury (107)
  • 4.4. Generowanie nieba za pomocą tekstury (109)
    • 4.4.1. Czym jest skybox? (109)
    • 4.4.2. Utworzenie nowego materiału skyboxu (110)
  • 4.5. Praca z niestandardowymi modelami 3D (112)
    • 4.5.1. Który format pliku wybrać? (113)
    • 4.5.2. Eksport i import modelu (114)
  • 4.6. Tworzenie efektów specjalnych za pomocą systemu cząstek (116)
    • 4.6.1. Dostosowanie parametrów w domyślnym efekcie systemu cząstek (117)
    • 4.6.2. Zastosowanie nowej tekstury dla ognia (118)
    • 4.6.3. Dołączenie efektu systemu cząstek do obiektu 3D (120)
  • 4.7. Podsumowanie (121)

CZĘŚĆ II. KOMFORTOWA PRACA (123)

Rozdział 5. Utworzenie gry 2D za pomocą funkcji oferowanych przez Unity (125)

  • 5.1. Przygotowanie środowiska dla grafiki 2D (126)
    • 5.1.1. Przygotowanie projektu (127)
    • 5.1.2. Wyświetlanie obrazów 2D (sprite'ów) (129)
    • 5.1.3. Przełączenie kamery do trybu 2D (130)
  • 5.2. Utworzenie obiektu karty i zdefiniowanie jego reakcji na kliknięcie (133)
    • 5.2.1. Utworzenie obiektu sprite'ów (133)
    • 5.2.2. Kod obsługujący dane wejściowe myszy (133)
    • 5.2.3. Odkrycie karty po jej kliknięciu (134)
  • 5.3. Wyświetlanie różnych obrazów kart (135)
    • 5.3.1. Programowe wczytywanie obrazów (135)
    • 5.3.2. Ustawienie obrazu na podstawie niewidocznego obiektu wraz ze skryptem SceneController (136)
    • 5.3.3. Utworzenie siatki kart (138)
    • 5.3.4. Tasowanie kart (140)
  • 5.4. Utworzenie i ocena dopasowania (141)
    • 5.4.1. Przechowywanie i porównywanie odkrytych kart (142)
    • 5.4.2. Ukrycie niedopasowanych kart (143)
    • 5.4.3. Wyświetlenie punktacji (144)
  • 5.5. Przycisk zerujący grę (146)
    • 5.5.1. Programowanie komponentu UIButton za pomocą metody SendMessage() (146)
    • 5.5.2. Wywołanie LoadLevel z poziomu skryptu SceneController (149)
  • 5.6. Podsumowanie (150)

Rozdział 6. Umieszczenie interfejsu użytkownika 2D w grze 3D (151)

  • 6.1. Zanim przystąpisz do tworzenia kodu... (153)
    • 6.1.1. Tryb bezpośredniego graficznego interfejsu użytkownika czy zaawansowany interfejs 2D? (153)
    • 6.1.2. Planowanie układu (154)
    • 6.1.3. Import obrazów interfejsu użytkownika (155)
  • 6.2. Konfiguracja graficznego interfejsu użytkownika (156)
    • 6.2.1. Utworzenie płótna dla interfejsu (156)
    • 6.2.2. Przyciski, obrazy i etykiety tekstowe (157)
    • 6.2.3. Kontrolowanie położenia elementów interfejsu użytkownika (160)
  • 6.3. Programowanie interaktywności interfejsu użytkownika (161)
    • 6.3.1. Programowanie niewidocznego komponentu UIController (162)
    • 6.3.2. Utworzenie wyskakującego okna (164)
    • 6.3.3. Ustawienie wartości za pomocą suwaka i pola tekstowego (167)
  • 6.4. Uaktualnianie gry przez udzielanie odpowiedzi na zdarzenia (170)
    • 6.4.1. Integracja systemu zdarzeń (170)
    • 6.4.2. Rozgłaszanie i nasłuchiwanie zdarzeń pochodzących ze sceny (171)
    • 6.4.3. Rozgłaszanie i nasłuchiwanie zdarzeń pochodzących z okna HUD (172)
  • 6.5. Podsumowanie (174)

Rozdział 7. Utworzenie gry 3D z widokiem z perspektywy trzeciej osoby - animacja i ruch postaci gracza (175)

  • 7.1. Dostosowanie widoku kamery do perspektywy trzeciej osoby (177)
    • 7.1.1. Import postaci używanej w grze (178)
    • 7.1.2. Dodanie cieni na scenie (179)
    • 7.1.3. Orbitowanie kamery wokół postaci gracza (181)
  • 7.2. Programowanie kontrolek ruchu względem kamery (184)
    • 7.2.1. Rotacja postaci gracza w celu ustawienia jej zgodnie z kierunkiem ruchu (184)
    • 7.2.2. Poruszanie się do przodu we wskazanym kierunku (187)
  • 7.3. Implementacja akcji skoku (188)
    • 7.3.1. Zastosowanie szybkości i przyśpieszenia w pionie (189)
    • 7.3.2. Modyfikacja wykrywania ziemi w celu obsługi krawędzi i zboczy (190)
  • 7.4. Konfiguracja animacji postaci gracza (195)
    • 7.4.1. Zdefiniowanie klipów animacji w zaimportowanym modelu (197)
    • 7.4.2. Utworzenie kontrolera animacji (199)
    • 7.4.3. Utworzenie kodu źródłowego używającego kontrolera animacji (202)
  • 7.5. Podsumowanie (204)

Rozdział 8. Dodanie do gry interaktywnych urządzeń i przedmiotów (205)

  • 8.1. Utworzenie drzwi oraz innych urządzeń (206)
    • 8.1.1. Drzwi otwierane i zamykane po naciśnięciu klawisza (207)
    • 8.1.2. Sprawdzenie odległości i stanięcie przed otwierającymi się drzwiami (208)
    • 8.1.3. Użycie monitora zmieniającego kolor (210)
  • 8.2. Interakcja z obiektami przez ich uderzanie (211)
    • 8.2.1. Kolizja z przeszkodą stosującą zasady fizyki (212)
    • 8.2.2. Obsługa drzwi za pomocą naciśnięcia (213)
    • 8.2.3. Zbieranie przedmiotów rozrzuconych na poziomie gry (216)
  • 8.3. Zarządzanie danymi magazynu i stanem gry (217)
    • 8.3.1. Przygotowanie menedżerów gracza i magazynu (218)
    • 8.3.2. Programowanie menedżera gry (219)
    • 8.3.3. Przechowywanie danych magazynu w obiekcie kolekcji - lista kontra słownik (224)
  • 8.4. Interfejs użytkownika dla magazynu przedmiotów (226)
    • 8.4.1. Wyświetlanie w interfejsie użytkownika zebranych przedmiotów (227)
    • 8.4.2. Przygotowanie klucza niezbędnego do otworzenia drzwi (229)
    • 8.4.3. Przywrócenie dobrej kondycji gracza przez użycie odpowiedniego pakietu (231)
  • 8.5. Podsumowanie (232)

CZĘŚĆ III. MOCNE ZAKOŃCZENIE (233)

Rozdział 9. Połączenie gry z internetem (235)

  • 9.1. Utworzenie sceny zewnętrznej (237)
    • 9.1.1. Wygenerowanie nieba za pomocą skyboxu (237)
    • 9.1.2. Konfiguracja atmosfery kontrolowanej przez kod (238)
  • 9.2. Pobieranie danych dotyczących prognozy pogody z internetu (241)
    • 9.2.1. Żądanie danych WWW za pomocą podprocedur (244)
    • 9.2.2. Przetwarzanie danych XML (248)
    • 9.2.3. Przetwarzanie danych w formacie JSON (251)
    • 9.2.4. Zmiana sceny na podstawie danych dotyczących prognozy pogody (252)
  • 9.3. Dodanie bilbordu pochodzącego z sieci (254)
    • 9.3.1. Wczytywanie obrazów z internetu (254)
    • 9.3.2. Wyświetlenie obrazu na bilbordzie (257)
    • 9.3.3. Buforowanie pobranego obrazu w celu jego wielokrotnego użycia (258)
  • 9.4. Przekazanie danych do serwera WWW (260)
    • 9.4.1. Monitorowanie aktualnej pogody - wykonywanie żądań typu POST (261)
    • 9.4.2. Kod PHP działający po stronie serwera WWW (263)
  • 9.5. Podsumowanie (263)

Rozdział 10. Odtwarzanie dźwięku - muzyka i efekty dźwiękowe (265)

  • 10.1. Import efektów dźwiękowych (266)
    • 10.1.1. Obsługiwane formaty plików (266)
    • 10.1.2. Import plików muzycznych (268)
  • 10.2. Odtwarzanie efektów dźwiękowych (270)
    • 10.2.1. Opis mechanizmu działania systemu audio - klip muzyczny kontra źródło kontra odbiorca (270)
    • 10.2.2. Zdefiniowanie zapętlonego dźwięku (271)
    • 10.2.3. Wywoływanie efektów dźwiękowych z poziomu kodu (272)
  • 10.3. Interfejs audio (274)
    • 10.3.1. Konfiguracja centralnego menedżera AudioManager (274)
    • 10.3.2. Interfejs użytkownika zmiany poziomu głośności (276)
    • 10.3.3. Odtwarzanie dźwięków interfejsu użytkownika (280)
  • 10.4. Muzyka odtwarzana w tle (281)
    • 10.4.1. Odtwarzanie muzyki w pętli (282)
    • 10.4.2. Oddzielna kontrola poziomu głośności muzyki (285)
    • 10.4.3. Wyciszenie między ścieżkami muzycznymi (288)
  • 10.5. Podsumowanie (290)

Rozdział 11. Zebranie wszystkiego w całość w pełnej grze (291)

  • 11.1. Przygotowanie akcji w grze RPG poprzez wykorzystanie innych projektów (293)
    • 11.1.1. Łączenie zasobów i kodu z wielu projektów (293)
    • 11.1.2. Programowanie kontrolek typu "wskaż i kliknij" - obsługa ruchu i urządzeń (296)
    • 11.1.3. Zastąpienie starego interfejsu użytkownika nowym (302)
  • 11.2. Opracowanie nadrzędnej struktury gry (309)
    • 11.2.1. Kontrolowanie przepływu misji i wielu poziomów gry (309)
    • 11.2.2. Ukończenie poziomu przez dotarcie do końca (313)
    • 11.2.3. Przegrana gracza po złapaniu go przez nieprzyjaciela (315)
  • 11.3. Obsługa postępów gracza w całej grze (317)
    • 11.3.1. Zapisanie i wczytanie informacji o postępach gracza w grze (317)
    • 11.3.2. Ukończenie całej gry przez przejście trzech poziomów (321)
  • 11.4. Podsumowanie (323)

Rozdział 12. Wdrożenie gry w urządzeniach graczy (325)

  • 12.1. Platformy tradycyjnych komputerów - Windows, macOS i Linux (327)
    • 12.1.1. Kompilacja aplikacji (328)
    • 12.1.2. Dostosowanie ustawień Player Settings - nazwa i ikona gry (328)
    • 12.1.3. Kompilacja zależna od platformy (330)
  • 12.2. Kompilacja aplikacji internetowej (331)
    • 12.2.1. Odtwarzacz Unity kontra HTML5 i WebGL (332)
    • 12.2.2. Utworzenie pliku Unity i testowej strony internetowej (332)
    • 12.2.3. Komunikacja z kodem JavaScript w przeglądarce WWW (332)
  • 12.3. Kompilacja na platformy mobilne - iOS i Android (335)
    • 12.3.1. Konfiguracja narzędzi kompilacji (336)
    • 12.3.2. Kompresja tekstur (339)
    • 12.3.3. Opracowywanie wtyczek (341)
  • 12.4. Podsumowanie (349)

Zakończenie (351)

Dodatek A. Nawigacja po scenie i skróty klawiszowe (355)

  • A.1. Nawigacja po scenie za pomocą myszy (355)
  • A.2. Najczęściej używane skróty klawiszowe (356)

Dodatek B. Narzędzia zewnętrzne używane wraz z Unity (359)

  • B.1. Narzędzia programistyczne (359)
    • B.1.1. Visual Studio (359)
    • B.1.2. Xcode (360)
    • B.1.3. Android SDK (360)
    • B.1.4. SVN, Git lub Mercurial (360)
  • B.2. Aplikacje do grafiki 3D (360)
    • B.2.1. Maya (361)
    • B.2.2. 3ds Max (361)
    • B.2.3. Blender (361)
  • B.3. Edytory grafiki 2D (361)
    • B.3.1. Photoshop (361)
    • B.3.2. GIMP (362)
    • B.3.3. TexturePacker (362)
  • B.4. Oprogramowanie audio (362)
    • B.4.1. Pro Tools (362)
    • B.4.2. Audacity (362)

Dodatek C. Modelowanie ławki w programie Blender (363)

  • C.1. Utworzenie geometrii siatki (364)
  • C.2. Mapowanie tekstury w modelu (367)

Dodatek D. Zasoby dostępne w internecie (371)

  • D.1. Dodatkowe samouczki (371)
  • D.2. Biblioteki kodu (372)

Skorowidz (375)

  • Title: Unity w akcji
  • Author: Joe Hocking
  • Original title: Unity in Action: Multiplatform Game Development in C# with Unity 5
  • Translation: Robert Górczyński
  • ISBN: 978-83-283-3520-2, 9788328335202
  • Date of issue: 2017-08-09
  • Format: Ebook
  • Item ID: uniwak
  • Publisher: Helion