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.

Osoby które kupowały "Unity w akcji", wybierały także:

• Unity na start! Programowanie dla nastolatków 44,84 zł, (13,90 zł -69%)
• Unity 2019. Kurs wideo. Wyścigi 2D - ostatnie szlify 79,00 zł, (31,60 zł -60%)
• Unity 2019. Kurs video. Wyścigi 2D - rozbudowa gry 79,00 zł, (31,60 zł -60%)
• Unity 2019. Kurs video. Wyścigi 2D - budujemy prototyp 79,00 zł, (31,60 zł -60%)
• Tworzenie gier multiplayer dla programistów Unity. Poziom pierwszy. Kurs video 59,00 zł, (23,60 zł -60%)

Spis treści

Unity w akcji eBook -- spis treści

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)