Liczba wyświetleń postów: 19 374

Rozmawialiśmy o tym, jak możesz stworzyć własną grę na Androida, korzystając z silnika Unreal Engine. W tym artykule przyjrzymy się innemu równie popularnemu silnikowi tworzenia gier - Jedność.

Unity to bardzo znany silnik wśród niezależnych deweloperów. Zasadniczo jest to silnik wieloplatformowy, który pozwala na rozwój 3D- i 2D-Gry. Cechą wyróżniającą Unity na tle pozostałych silników jest niska bariera wejścia dla początkujących z bogatym zestawem narzędzi dla profesjonalistów. Z drugiej strony, cross-platform pozwala tworzyć aplikacje na dowolną platformę, od gier komputerowych po urządzenia mobilne.

O systemie subskrypcji należy powiedzieć osobno, ponieważ Unity nie jest całkowicie darmowym produktem. Istnieje kilka rodzajów subskrypcji:

• Osobisty... Darmowa wersja zawierająca wszystkie główne funkcje silnika. Ma następujące ograniczenie: roczny dochód lub kwota zebranych środków nie powinna przekraczać 100000$ .
• Plus... Za 35 dolarów miesięcznie dostępne są różne raporty i analizy, a także możliwość zmiany ekranu powitalnego, 20% -ty rabat na zakupy w Magazyn aktywów i różne drobne korzyści. Ma następujące ograniczenie: dochód za rok lub kwota zebranych środków nie powinna przekraczać 200000$ .
• Zawodowiec... Za 125 USD miesięcznie zawiera wszystkie zalety tej wersji Plus a do tego profesjonalna obsługa i wsparcie premium. Brak ograniczeń dotyczących obrotów lub wysokości środków.
• Oddzielne wersje dla biznesu (używane przez duże firmy).

Dlatego dla niezależnych programistów dysponujących niewielkim budżetem wersja Osobisty lub Plus, w przeciwnym razie będziesz musiał zapisać się Zawodowiec... W tym artykule użyjemy darmowej wersji do pierwszego uruchomienia.

Krok 1. Instalowanie Unity

Aby rozpocząć instalację Unity, musisz przejść do witryny Unity Store, gdzie zostaniesz poproszony o wybranie typu subskrypcji. Jak wspomniano powyżej, wybieramy Osobisty.

Zostaniesz poproszony o zaakceptowanie warunków użytkowania i pobranie instalatora. Możesz również zobaczyć wymagania systemowe do pracy z Unity.

Po uruchomieniu instalatora zostaniesz poproszony o wybranie składników do zainstalowania. Ponieważ musimy stworzyć aplikację na Androida, zaznacz pole Wsparcie dla budowania Androida... Ponadto, jeśli chcesz, zamiast Unity, możesz zainstalować Visual Studio Community 2017 do programowania C #.

Następnie pozostaje tylko wybrać ścieżkę instalacji i rozpocząć instalację Unity.

Krok 2. Zarejestruj i skonfiguruj Unity

Po zakończeniu instalacji i uruchomieniu Unity zapraszamy do logowania się na nasze konto.

Następnie ponownie zostaniesz poproszony o wybranie subskrypcji, skupimy się również na osobistym. W takim przypadku musisz potwierdzić, że firma ma mniej niż 100 000 USD rocznych przychodów lub że Unity jest używana do celów szkoleniowych.

Na koniec zostaniesz poproszony o wypełnienie małej ankiety, w której musisz odpowiedzieć na to, co robisz i w jakim celu instalujesz Unity.

Krok 3. Tworzenie nowego projektu

Po skonfigurowaniu Unity przechodzimy do ekranu wyboru projektu \\ utwórz. Tutaj musisz kliknąć Nowyaby stworzyć nowy projekt.

Następnie w wyświetlonym oknie zostaniesz poproszony o wprowadzenie nazwy projektu i katalogu, w którym będzie on zlokalizowany. Nie zapomnij też zaznaczyć tego pola 3Dkorzystać z edytora w 3D.

Kiedy skończysz, kliknij Utwórz projektstworzyć projekt. Następnie otworzy się okno edytora ze wstępnie wygenerowaną sceną.

Nie będziemy jeszcze zajmować się zawiłościami programowania i weźmiemy jako przykład ukończoną grę. Do tego jest Magazyn aktywów, który zawiera ogromną liczbę gotowych modeli, animacji, dźwięków (a nawet gier), zarówno płatnych, jak i bezpłatnych.

Aby otworzyć magazyn zasobów, musisz w menu Okno wybierać Magazyn aktywów (kombinacja klawiszy Ctrl + 9).

Otworzy się okno sklepu. Wpiszmy w pasku wyszukiwania „ przykładowa gra w stylu flappy bird”i otwórz darmowy przykład, którego użyjemy w naszym projekcie.

Klikając Ściągnij a po pobraniu możesz go zaimportować do swojego projektu. Aby to zrobić, kliknij Import, po czym pojawi się ostrzeżenie informujące, że ustawienia projektu zostaną zmienione po imporcie.

Po wyrażeniu zgody na import pojawi się okno, w którym należy wybrać komponenty do importu. Zaznacz wszystko i kliknij Import.

Po zakończeniu importu zobaczysz nowe pliki w Eksploratorze projektów. To są pliki gry. Aby otworzyć scenę w edytorze, rozwiń Styl Flappy Bird - Sceny i kliknij dwukrotnie Główny.

W rezultacie scena gry pojawi się w oknie edytora 3D.

Możesz sprawdzić, jak gra działa bezpośrednio w Unity, klikając przycisk Grać nad oknem edytora.

Krok 4. Konfiguracja narzędzi Android

Uwaga: Jeśli użyjesz Android Studio, masz już zainstalowane wszystkie niezbędne komponenty i możesz bezpiecznie przejść do następnego kroku.

Aby zbudować wynikową grę na Androida, musisz zainstalować następujące narzędzia:

• Java Development Kit (JDK). Możesz go pobrać z witryny Java. Klikając w link, zobaczysz na samej górze Platforma Java (JDK), Kliknij Ściągnij obok etykiety, a następnie wybierz swój system operacyjny i rozpocznij pobieranie. Następnie postępuj zgodnie z instrukcjami instalatora.
• Android SDK... Najłatwiejszym sposobem uzyskania najnowszej wersji jest pobranie Android Studio, które jest dostarczane z tym zestawem SDK. Aby to zrobić, przejdź do witryny Android Studio i kliknij Pobierz Android Studio... Instalator Android Studio instaluje podstawowe składniki Android SDK wymagane do programowania systemu Android.

Krok 5. Przygotowanie projektu do uruchomienia

Najpierw musisz zmienić platformę programistyczną na Androida. Aby to zrobić, w Unity otwórz menu Plik i wybierz Ustawienia kompilacji.

W wyświetlonym oknie wybierz Android a następnie naciśnij Przełącz platformę.

Przełącznik platformy mówi nam, że będziemy budować aplikację na Androida. Oznacza to, że kiedy budujemy aplikację, Unity będzie tworzyć Plik APK... Zmiana platformy zmusza również Unity do ponownego zaimportowania wszystkich zasobów projektu. W przypadku małego projektu nie zajmie to dużo czasu, ale należy pamiętać, że w przypadku dużych projektów operacja ta może zająć dużo czasu.

Teraz musimy podać nazwę pakietu dla aplikacji.

Uwaga: Nazwa pakietu jest unikalnym identyfikatorem aplikacji, jest zapisana w odwrotnym stylu DNS w formacie com.CompanyName.ProductName... Po opublikowaniu aplikacji w Google Play nie można zmienić nazwy pakietu.

Aby to zrobić, przejdź do menu Edytować i wybierz Ustawienia projektu - gracz.

Po prawej stronie Unity otworzy się okno z wieloma różnymi ustawieniami, takimi jak wersja aplikacji, docelowy i minimalny zestaw SDK, wybór ikon itp. Tutaj potrzebujemy w bloku Inne ustawienia znaleźć Identyfikacja i ustaw nazwę pakietu w polu Nazwa pakietu... W razie potrzeby można również zmienić inne parametry.

Teraz pozostaje tylko określić ścieżkę do Android SDK i JDK. Aby to zrobić, przejdź do menu i wybierz Edytuj preferencje.

W wyświetlonym oknie przejdź do Narzędzia zewnętrzne i na polach SDK i JDK określ odpowiednie ścieżki, a następnie zamknij okno.

Krok 6. Zbuduj i uruchom aplikację

Czas zbudować swoją pierwszą aplikację Unity. Aby to zrobić, wybierz z menu Plik - Ustawienia kompilacji... Otworzy się okno, w którym będziesz musiał dodać scenę do złożenia. Ponieważ mamy już otwartą scenę w edytorze, po prostu kliknij Dodaj otwarte scenyaby dodać go do montażu, po dodaniu zobaczysz go na liście scen.

Pozostaje tylko nacisnąć Budowaća wtedy Unity zacznie budować aplikację. Wcześniej możesz zostać poproszony o wybranie folderu, w którym zostaną zapisane zebrane pliki aplikacji, a także o nazwę pliku APK.

Uwaga: w tej chwili, jeśli masz zainstalowaną wersję alfa w Android SDK Narzędzia do budowania (wersja 28.0.0-rc1), podczas budowania Gradle zwróci błąd. Aby to naprawić, po prostu usuń tę wersję z Android SDK.

W rezultacie zmontowany plik APK pojawi się w określonym folderze, gotowy do instalacji na emulatorze lub na prawdziwym urządzeniu.

Zobaczmy, co znajduje się w złożonym pliku APK. Aby to zrobić, użyjemy narzędzia Analizator APKktóry jest dołączony do Android Studio,

Rozmiar nieskompresowanego pliku APK to 21,1 MB, w skompresowanym pliku 20,9 MB... Jak widać na wykresie, większość wolumenu zajmują biblioteki innych firm dodane przez Unity. Następnie w majątekwszystkie zasoby używane w zmontowanej scenie są zlokalizowane. Plik classes.dex zawiera wszystko 89 zajęcia i 479 metody.

Ponadto, jeśli spojrzysz na AndroidManifest.xmlaplikacja składa się z jednej czynności.

Wniosek

To wszystko. W tym artykule dowiedzieliśmy się, jak zainstalować i skonfigurować Unity, a także stworzyliśmy naszą pierwszą aplikację na Androida.

Jak szybko napisać grę na Androida w Unity

W dzisiejszych czasach każdy może odnieść sukces w tworzeniu gier lub aplikacji mobilnych bez tytanicznych wysiłków. Przykładem takiego przypadku jest Dong Nguyen, który opracował Flappy Bird. Gra nie posiadała skomplikowanej mechaniki ani grafiki, ale to nie przeszkodziło jej stać się popularną i przynosić swojemu twórcy pięćdziesiąt tysięcy dolarów dziennie. Jednak w tej grze nie było nic niezwykłego. Aby odnieść sukces, wystarczyło znaleźć się we właściwym miejscu we właściwym czasie i odrobinę szczęścia. Może się to zdarzyć dzisiaj, potrzebujesz tylko odpowiedniego pomysłu.

Aby pokazać, jak łatwo jest napisać coś takiego, dzisiaj napiszemy naszego Flappy Bird with Unity w zaledwie 10 minut.

Grywalna postać

Najpierw utwórz nowy projekt i upewnij się, że wybrano 2D.

Załaduj swojego ptaka na scenę. Nie zapomnij włączyć swojej fantazji!

Następnie dostosuj rozmiar duszka, jak chcesz, przeciągając go za róg w żądanym kierunku. Sprite powinien być widoczny w oknie hierarchii po lewej stronie. Wszystkie obiekty na scenie są w nim widoczne, a na razie powinny być tylko dwa: kamera i ptak.

Przeciągnij aparat na ptaka i puść. Kamera powinna znajdować się pod ptakiem, co oznacza, że \u200b\u200bkamera jest teraz „dzieckiem” ptaka. Pozycja kamery zostanie teraz ustalona względem ptaka. Jeśli ptak porusza się do przodu, kamera robi to samo.

Wybierz ptaka ponownie w scenie lub w oknie hierarchii. Zobaczysz listę opcji i atrybutów po prawej stronie w oknie o nazwie Inspector. Tutaj możesz zarządzać różnymi zmiennymi powiązanymi z określonym obiektem.

Teraz kliknij Dodaj komponent. Wybierz Physics2D\u003e Rigidbody2D - to gotowy zestaw instrukcji dotyczących zastosowania grawitacji do naszej postaci. Kliknij Wiązania w tym panelu, a następnie wybierz opcję Zablokuj obrót Z. Zapobiegnie to obracaniu się ptaka wraz z aparatem w kole.

W ten sam sposób dodaj Polygon Collider, który powie Unity, gdzie są granice postaci. Naciśnij Play i zobacz, jak duszek wraz z kamerą spada w nieskończoność.

Na razie w porządku!

Teraz czas zacząć latać postacią, ponieważ nie będzie to trudne.

Najpierw musisz utworzyć skrypt C #. Utwórz dla niego folder (kliknij prawym przyciskiem myszy gdzieś w zasobach i utwórz folder „Scripts”), kliknij prawym przyciskiem myszy i wybierz opcję Utwórz\u003e Skrypt C #.

Nazwijmy to „Postacią”. Kliknij dwukrotnie, aby otworzyć go w swoim IDE, czy to MonoDevelop, czy Visual Studio. Następnie dodaj następujący kod:

Public class Character: MonoBehaviour (public Rigidbody2D rb; public float moveSpeed; public float flapHeight; // Jest to potrzebne do zainicjowania void Start () (rb \u003d GetComponent ();) // Aktualizacja jest wywoływana raz na klatkę void Update () (rb .velocity \u003d new Vector2 (moveSpeed, rb.velocity.y); if (Input.GetMouseButtonDown (0)) (rb.velocity \u003d new Vector2 (rb.velocity.x, flapHeight);) if (transform.position.y\u003e 18 || transform.position.y< -19) { Death(); } } public void Death() { rb.velocity = Vector3.zero; transform.position = new Vector2(0, 0); } }

Ten kod robi dwie rzeczy. Sprawia, że \u200b\u200bpostać porusza się do przodu z prędkością, którą określamy w inspektorze, i stwarza wrażenie lotu ptaka. Metoda Update () jest wywoływana wielokrotnie w trakcie gry, więc wszystko, co tu umieścisz, będzie działać w sposób ciągły. W tym przypadku dodajemy trochę prędkości do naszego obiektu. Zmienna rb to skrypt RigidBody2D, który zastosowaliśmy wcześniej do naszego obiektu, więc pisząc rb.velocity, odnosimy się do prędkości obiektu.

Stuknięcie w ekran jest interpretowane przez Unity jako kliknięcie myszą, jeśli używasz urządzenia mobilnego. Po kliknięciu sprawiamy, że postać przesuwa się nieco w górę.

Zmienna moveSpeed \u200b\u200bbędzie odpowiadać za prędkość ruchu, a zmienna flapHeight - za wzrost wysokości lotu ptaka po każdym kliknięciu. Ponieważ te zmienne są zadeklarowane jako publiczne, możemy je zmienić poza skryptem.

Metoda Death () jest również deklarowana jako publiczna, co oznacza, że \u200b\u200bmogą ją wywoływać inne obiekty i skrypty. Ta metoda po prostu zwraca pozycję znaku na początek. Będzie również używany za każdym razem, gdy postać leci zbyt wysoko lub nisko. Wkrótce zrozumiesz, dlaczego został ogłoszony jako publiczny. Linia rb.velocity \u003d Vector3.zero; jest potrzebny, aby usunąć impuls - nie chcemy, aby postać upadała coraz szybciej po każdej śmierci?

Teraz możesz wyjść z IDE i dodać skrypt jako komponent do swojej postaci. Aby to zrobić, wybierz naszego ptaka i kliknij Dodaj komponent\u003e Skrypty\u003e Znak. Teraz możemy zdefiniować moveSpeed \u200b\u200bi flapHeight w inspektorze (do tego służą zmienne publiczne). Przypiszmy zmiennym odpowiednio wartości 3 i 5.

I jeszcze jedno: w inspektorze musisz dodać tag do postaci. Aby to zrobić, kliknij w miejscu, w którym jest napisane Tag: Untagged, a następnie wybierz Player z listy rozwijanej.

Przeszkody

Teraz dodajmy przeszkody: rury. Ktoś znajduje grzyby w rurach, a ktoś inny znajduje ich śmierć.

Przeciągnij duszka rury do sceny, w której powinna znajdować się pierwsza przeszkoda i nazwij ją pipe_up.
Teraz stwórzmy nowy skrypt o nazwie Pipe:

Public class Pipe: MonoBehaviour (private Character character; // Jest to potrzebne do inicjalizacji void Start () (character \u003d FindObjectOfType ();) // Update jest wywoływany raz na klatkę void Update () (if (character.transform.position.x - transform.position.x\u003e

Dodaj ten skrypt do duszka potoku w taki sam sposób jak poprzednio. Tym samym rura powróci na ekran po wyjściu poza jego lewą granicę. Jeszcze nic tu nie zrobiliśmy, ale wrócimy do tego.

Metoda OnCollisionEnter2D () jest wywoływana za każdym razem, gdy potok wchodzi w interakcję ze znakiem. Następnie wywoływana jest wcześniej utworzona metoda Death (), która powoduje powrót gracza do punktu wyjścia.

Mamy więc jedną rurkę, która od czasu do czasu pojawia się i zanika na drugim końcu ekranu. Jeśli go uderzysz, umrzesz.

Rury odwrócone

W tej chwili mamy tylko jednego duszka fajki. Dodajmy kolejny. Aby to zrobić, kliknij prawym przyciskiem myszy w oknie hierarchii, kliknij Nowy obiekt 2D\u003e Sprite, a następnie wybierz sprite, którego chcesz użyć. Jeszcze łatwiej jest po prostu ponownie przeciągnąć i upuścić plik na scenę.

Nazwij duszka pipe_down. W inspektorze pod Sprite Renderer wybierz opcję Odwróć Y, aby odwrócić potok do góry nogami. Dodaj to samo RigidBody2D.

Teraz napiszmy nowy skrypt C # o nazwie PipeD. Będzie zawierał podobny kod:

Klasa publiczna PipeD: MonoBehaviour (private Character character; // Jest to potrzebne do inicjalizacji void Start () (character \u003d FindObjectOfType ();) // Update jest wywoływany raz na klatkę void Update () (if (character.transform.position.x - transform.position.x\u003e 30) ()) void OnCollisionEnter2D (inne Collision2D) (if (other.gameObject.tag \u003d\u003d "Player") (character.Death ();)))

Prefabrykaty

Tak więc ten kod wystarczy nam do stworzenia całej gry. Moglibyśmy przesuwać rury na prawą stronę ekranu za każdym razem, gdy znikają, lub kopiować i wklejać tyle rur, ile chcielibyśmy widzieć w całej grze.

Jeśli pójdziesz pierwszą drogą, upewnienie się, że rury są takie, jak powinny po losowym wygenerowaniu, i utrzymanie uczciwego przebiegu rzeczy byłoby trudne. Po śmierci postaci mogły pojawić się kilometry od pierwszej rury!

Jeśli pójdziesz drugą drogą, wszystko skończy się nadmiernym zużyciem pamięci, z wynikającym z tego spowolnieniem gry i ograniczoną odtwarzalnością, ponieważ wszystko jest zawsze w tym samym miejscu.

Zamiast tego użyjmy prefabrykatów. Mówiąc najprościej, zamienimy nasze rury w szablony, których będziemy mogli następnie użyć do wydajnego tworzenia większej liczby rur według potrzeb. Jeśli są tutaj programiści, potraktuj skrypt potoku jako klasę, a potoki jako instancje tego obiektu.

Aby to zrobić, utwórz nowy folder „Prefabrykaty”. Następnie przeciągnij pipe_up i pipe_down z okna hierarchii do folderu.

Za każdym razem, gdy przeciągasz obiekt z tego folderu na scenę, będzie on miał te same właściwości, więc nie musisz ciągle dodawać komponentów. Co więcej, jeśli zmienisz rozmiar komponentu w folderze, wpłynie to na wszystkie rury w grze i nie musisz zmieniać każdego z nich osobno.

Jak możesz sobie wyobrazić, znacznie zaoszczędzi to nasze zasoby. Oznacza to również, że możemy wchodzić w interakcje z obiektami z kodu. Możemy tworzyć instancje naszych rur.

Najpierw dodaj ten kod do instrukcji warunkowej w metodzie Update () skryptu potoku, którą pozostawiliśmy puste:

Void Update () (if (character.transform.position.x - transform.position.x\u003e 30) (float xRan \u003d Random.Range (0, 10); float yRan \u003d Random.Range (-5, 5); Instancja (gameObject, new Vector2 (character.transform.position.x + 15 + xRan, -10 + yRan), transform.rotation); Destroy (gameObject);))

Jest to potrzebne do utworzenia instancji naszego gameObject. Rezultatem jest nowa identyczna kopia. W Unity każde użycie słowa gameObject odnosi się do obiektu, do którego skrypt jest obecnie dołączony - w naszym przypadku potoku.

Ponownie generujemy nasze rury w przypadkowych odmianach, aby było fajniej.

Ale zamiast robić to samo w skrypcie PipeD, generujemy oba obiekty w tym samym miejscu. W ten sposób możemy łatwo ustawić położenie drugiej rury względem pierwszej. Oznacza to również, że potrzebujemy mniej kodu dla PipeD.

Utwórz publiczny obiekt gameObject o nazwie pipeDown. Następnie zaktualizuj swój kod w ten sposób:

If (character.transform.position.x - transform.position.x\u003e 30) (float xRan \u003d Random.Range (0, 10); float yRan \u003d Random.Range (-5, 5); float gapRan \u003d Random.Range (0, 3); Instancja (gameObject, nowy Vector2 (character.transform.position.x + 15 + xRan, -11 + yRan), transform.rotation); Instancja (pipeDown, nowy Vector2 (character.transform.position.x + 15 + xRan, 12 + gapRan + yRan), transform.rotation); Destroy (gameObject);)

Wróć do Unity i przeciągnij prefabrykat pipe_down z folderu prefabrykatów (to jest ważne!) Do miejsca, w którym jest napisane „Pipe Down” (zwróć uwagę, jak nasza skrzynia wielbłąda jest zastąpiona spacją) na spriterze. Jeśli pamiętasz, zdefiniowaliśmy Pipe Down jako publiczny obiekt gameObject, który daje nam możliwość określenia, czym jest ten obiekt z dowolnego miejsca - w tym przypadku przez inspektora. Wybierając prefabrykat dla tego obiektu, upewniamy się, że po utworzeniu potoku będzie on zawierał wszystkie atrybuty i skrypt, które dodaliśmy wcześniej. Nie tworzymy tylko duszka, ale tworzymy ponownie obiekt z zderzaczem, który może zabić postać.

Wszystko, co dodamy w tym samym miejscu w skrypcie PipeD, to po prostu Destroy (gameObject), dzięki czemu potok ulegnie samozniszczeniu, gdy zejdzie z lewej krawędzi ekranu.

Jeśli rozpoczniesz grę teraz, ekran automatycznie przesunie się dalej i zginiesz, jeśli trafisz na którąkolwiek z rur. Leć wystarczająco daleko, a te rury znikną i pojawią się ponownie przed sobą.

Niestety między rurami jest dużo miejsca, a ekran wygląda na pusty. Moglibyśmy to naprawić, dodając kilka prefabrykatów do naszej sceny, aby utworzyć potok ze stale pojawiających się rur. Jednak lepiej byłoby wygenerować potoki w skrypcie. Jest to ważne, ponieważ w przeciwnym razie po śmierci postaci rury na początku ścieżki zostaną zniszczone i ponownie utworzy się pusta przestrzeń.

W ten sposób możemy stworzyć kilka pierwszych rur podczas każdego ładowania gry i przywrócić wszystko na swoje miejsce po śmierci postaci.

Niekończący się lot

Teraz utwórzmy zmienne publiczne pipe_up i pipe_down w skrypcie znaków. To da ci możliwość odniesienia się do wygenerowanych obiektów poprzez przeciąganie i upuszczanie prefabrykatów na obiekt znakowy, tak jak wtedy, gdy dodaliśmy pipe_down do skryptu Pipe.

Musimy dodać te zmienne:

Public GameObject pipe_up; public GameObject pipe_down;

Następnie napiszemy taką metodę:

Public void BuildLevel () (Instancja (pipe_down, new Vector3 (14, 12), transform.rotation); Instancja (pipe_up, new Vector3 (14, -11), transform.rotation); Instancja (pipe_down, new Vector3 (26, 14), transform.rotation); Instancja (pipe_up, new Vector3 (26, -10), transform.rotation); Instancja (pipe_down, new Vector3 (38, 10), transform.rotation); Instancja (pipe_up, new Vector3 ( 38, -14), transform.rotation); Instancja (pipe_down, new Vector3 (50, 16), transform.rotation); Instancja (pipe_up, new Vector3 (50, -8), transform.rotation); Instancja (pipe_down, nowy Vector3 (61, 11), transform.rotation); Instancja (pipe_up, new Vector3 (61, -13), transform.rotation);)

Nazwiemy to raz w metodzie Update () i raz w metodzie Death ().

Po uruchomieniu gry wywoływana jest funkcja Update (), a nasze potoki są instalowane zgodnie z podaną konfiguracją. Dzięki temu kilka pierwszych przeszkód będzie zawsze w tym samym miejscu. Po śmierci gracza rury trafią w te same miejsca.

Wróć do sceny w Unity i usuń dwie rury, które obecnie tam są. Twoja „gra” będzie wyglądać jak pusty ekran z ptakiem. Naciśnij Play i pojawią się rury, po kilku pierwszych ich położenie zostanie losowo określone.

Wreszcie

Więc stworzyliśmy całą grę! Dodaj licznik punktów, postaraj się, aby był bardziej oryginalny i zwiększaj poziom trudności gry w miarę postępów. Nie będzie też zbędne tworzenie menu. Dobrym pomysłem jest też zniszczenie rur na ekranie po śmierci postaci. Gdy skończysz, rozważ posiadanie w kieszeni gry gotowej do Sklepu Play! Kiedyś podobna gra uczyniła innego dewelopera bardzo bogatym, co dowodzi, że nie musisz być geniuszem programowania ani mieć za sobą bogatego wydawcy, aby odnieść sukces. Potrzebujesz tylko dobrego pomysłu i dziesięciu minut!

Chcesz pisać aplikacje na Androida, ale nie wiesz, od czego zacząć? W takim razie sprawdź nasze świetne narzędzie do nauki programowania na Androida.

Tworzenie aplikacji mobilnych jest jednym z najbardziej lukratywnych zajęć w branży komputerowej. Stworzenie gry na Androida kosztuje kilkaset lub kilka tysięcy dolarów, a zysk może sięgać nawet miliona dolarów. W związku z tym wiele osób jest zainteresowanych tworzeniem aplikacji na telefon. W tym artykule dowiesz się, jak za pomocą komputera stworzyć grę na Androida od podstaw, który silnik i konstruktor lepiej wybrać.

Żadna udana gra nie jest kompletna bez pięknej grafiki, więc stworzenie projektu jest jednym z najważniejszych etapów rozwoju. Projekt systemu operacyjnego Android jest wdrażany przy użyciu „dokumentu projektowego” lub projektowej stacji dokującej. Musisz zacząć tworzyć zabawkę dokładnie od jej szczegółowego badania. Plik zawiera:

1. Modele obiektów;
2. Specyfikacje funkcjonalne;
3. Zawartość gry;
4. Berło.

Rozważmy bardziej szczegółowo każdy z punktów.

Modele obiektów

To są informacje o funkcjonalności każdego elementu. Modele obiektów są odpowiedzialne za możliwość kupowania i sprzedawania przedmiotów, a także ulepszania cech gry postaci.

Specyfikacje funkcjonalne

Opisuje rozgrywkę, główne cechy każdej postaci. Zawiera również opis cech elementów gry - broni, apteczek, zbroi i innych. Zasadniczo specyfikacje funkcjonalne to zasady, według których toczy się rozgrywka. Im lepiej dopracowana jest ta sekcja, tym łatwiej będzie stworzyć wysokiej jakości grę na Androida.

Zawartość gry

To jest tekst wypełnienia gry. Opisuje dialogi bohaterów oraz jaką broń można wykorzystać do zadawania obrażeń, ile zdrowia zajmie trafienie, jakie cechy wzrosną podczas korzystania z różnego wyposażenia. Zawiera również szczegółowy opis każdej pozycji.

Berło

Interfejs to sposób interakcji użytkownika z grą. Zawiera przyciski, za pomocą których można sterować postacią, oraz sekcje menu: na przykład gra, punktacja, ustawienia, najlepsi gracze, pomoc. Jeśli nie masz doświadczenia w tworzeniu aplikacji na Androida to przed stworzeniem własnej pobierz ze Sklepu Play i przeanalizuj popularne gry i przenieś najlepsze rozwiązania do swojego projektu.

Silnik gry

Rdzeniem każdej gry jest silnik. To jest oprogramowanie, które pozwala Ci je rozwijać i uruchamiać. Zawiera cały zestaw programów, w tym silnik renderujący, silnik fizyczny, dźwięk, animację i inne. Aby ułatwić proces pisania programów, deweloperzy zewnętrzni tworzą własne silniki gier specjalnie dla aplikacji na Androida.

Każdy z nich oferuje inne funkcje: niektóre są zaprojektowane dla 3D, inne dla 2D, obsługa wielu platform może być obsługiwana. Istnieje ogromna liczba takich silników, ale jeśli jesteś początkującym, lepiej wybrać jeden z najpopularniejszych, ponieważ będą tam obecne wszystkie niezbędne funkcje.

UDK

Moment obrotowy 2d / 3d

Co to jest Game Builder?

Constructor to program, który łączy silnik gry i zintegrowane środowisko programistyczne. Projektant udostępnia proces deweloperski osobom nieposiadającym umiejętności programistycznych. Niektórzy konstruktorzy pozwalają na tworzenie gier określonych gatunków, podczas gdy inni mają maksymalną funkcjonalność, ale kosztują znacznie więcej pieniędzy. Dla początkującego twórcy aplikacji mobilnych wybór projektanta to jeden z najważniejszych momentów, bo od jej możliwości będą zależeć losy przyszłej aplikacji.

Konstruktor pozwala na tworzenie gier z różnych gatunków na systemy Windows, Android i iOS. Oferuje duży wybór gotowych lokacji, obiektów, postaci i projektów dźwiękowych, dzięki czemu stworzenie pierwszej gry na Androida nie zajmie dużo czasu. Użytkownicy zaznajomieni z językami programowania JS i C ++ mogą korzystać z wbudowanego GML. Jedyną wadą jest to, że program nie jest przetłumaczony na język rosyjski.

Wniosek

Stworzenie gry na Androida nie jest łatwym, ale bardzo dochodowym biznesem. Jeśli zdecydujesz się stworzyć grę i zarabiać na niej, najpierw wymyśl pomysł. Następnie napisz „dokument projektowy” i wybierz silnik gry, który może zmaksymalizować jego potencjał. Następnie możesz zacząć bezpośrednio tworzyć aplikację w projektancie.

Wideo

Aby dowiedzieć się więcej o procesie tworzenia gier na Androida, obejrzyj serię filmów poświęconych tej lekcji.

Unity to silnik większości dzisiejszych gier na różnych platformach. Za pomocą silnika naprawdę można tworzyć gry z przeznaczeniem na komputery (Windows, Linux, MacOS), telefony komórkowe, tablety (Android, iOS), a nawet konsole do gier PlayStation, Xbox, Nintendo.

Jak tworzyć gry w Unity?

Jedność opiera się na koncepcji zorientowanej na komponenty. W rzeczywistości każda gra składa się z masy obiektów, rozcieńczonych dodatkowymi komponentami. Przykładowo podczas tworzenia platformówki tworzymy GameObject, dodatkowo dołączamy do niego komponent graficzny, który odpowiada za wyświetlanie postaci, oraz komponent sterujący, który zapewnia sterowanie postacią za pomocą myszki, klawiatury, joysticka czy ekranu dotykowego. Silnik nie narzuca ograniczeń co do ilości takich modułów. Możemy dodać tyle komponentów do GameObject, ile potrzeba. Wszystkie prace nad silnikiem polegają na samym stworzeniu GameObject i zastosowaniu do nich odpowiednich komponentów.

Nowicjusze mogą być zdezorientowani pozorną prostotą procesu, chociaż tak nie jest. Aby stworzyć wyjątkową i popularną grę, musisz napisać wiele elementów od podstaw. Dokładniej, w środowisku Unity nazywa się to skryptem. Natywnym językiem skryptów jest C #, ale częściowo używane są również JavaScript i Boo (okrojona wersja Pythona). Nie jest łatwo stworzyć własne komponenty, można wręcz powiedzieć - jest to skomplikowana procedura bezpośrednio związana z klasycznym programowaniem. Bez odpowiedniej wiedzy programistycznej będzie to trudne.

Obsługiwane platformy

Wiele dużych projektów preferuje Unity ze względu na ogromną listę platform kompatybilnych z silnikiem. Gotową aplikację można faktycznie uruchomić na dowolnym komputerowym systemie operacyjnym, popularnych platformach mobilnych i SmartTV. Co możemy powiedzieć, nawet gry przeglądarkowe i aplikacje na określone platformy ( jak Tizen OS) są tworzone głównie w Unity.

Jednak nie wszystko jest tutaj takie gładkie. W razie potrzeby możesz napisać określone algorytmy w oparciu o kod niskopoziomowy, dla tego samego Androida musisz mieć gruntowną znajomość języka Java.

To samo dotyczy iOS. Inną cechą systemu iOS jest to, że można go opracować tylko na komputerze lub tablecie firmy Apple. W przypadku braku Macbooka lub podobnego urządzenia wydanie gry szybko się zatrzyma i Unity nie ma z tym nic wspólnego, samo Apple nakłada podobne ograniczenie. Wniosek jest prosty: jeśli są plany na rozwój systemu iOS, to wcześniej należy wybrać odpowiednie urządzenie do montażu.

Jak i gdzie stworzyć grę na silniku?

Możemy przeprowadzić długi proces tworzenia gry zarówno w systemie Windows, jak i Mac OS X. Istnieją już wersje edytora dla systemu Linux, ale na razie nie możemy liczyć na ich stabilną pracę. Deweloper spędza większość czasu na tworzeniu gry w edytorze Unity. Nadal musisz napisać dużo kodu skryptu, możemy go stworzyć w standardowym MonoDevelop lub w dowolnym edytorze innej firmy. Teraz aktywnie korzystają z Visual Studio, a także Sublime Text, ale tylko z odpowiednią konfiguracją.

Jak szybko i stosunkowo łatwo stworzyć prostą grę lub aplikację na Androida? Przeczytaj o tym w poniższym artykule, w którym omówiono pracę z silnikiem Unity3D.

Czy grasz w gry komputerowe? Jeśli tak, to na pewno w trakcie przechodzenia kolejnego hitu w grze czasami pojawiały się myśli w stylu: „Ale tutaj postąpiłbym źle!”. Chcesz sam zostać programistą? Następnie proponuję małą, ale bardzo rozrywkową „przygodę”;)

Co to jest silnik i dlaczego jest potrzebny?

Wcześniej, jeszcze w czasach pierwszych komputerów, gry i programy tworzone były metodą tzw. „Hardcore”. Oznacza to, że do pełnego rozwoju potrzebny był dość doświadczony programista, który dobrze zna swój język programowania i potrafi napisać prawie całą grę (w tym grafikę pikselową i efekty specjalne!) W prostym Notatniku. Takich ludzi było niewielu i byli bardzo cenieni (i nadal są doceniani) ...

Dziś próg wejścia w temat programowania znacznie spadł. Ułatwia to nie tylko dostępność literatury i wszelkiego rodzaju materiałów szkoleniowych, ale także coraz bardziej uproszczony proces rozwoju. W dzisiejszych czasach rzadko można znaleźć prawdziwych „hardkorowych” ludzi, ponieważ pojawiły się dość wygodne środowiska programistyczne, które nazywane są „silnikami”.

Istotą silnika jest to, że pozwala on zaimportować wszystkie niezbędne obiekty gry w uproszczonym trybie wizualnym, rozmieścić je na wirtualnej scenie oraz skonfigurować wszystkie ich parametry. Oznacza to, że zadaniem programisty jest tylko prawidłowe napisanie logiki gry!

Jednak za wygodę pracy trzeba zapłacić pewien wzrost wielkości projektu (czasem nawet kilkakrotnie!) W porównaniu z jego analogiem, napisanym po staremu „hardcore”. Z tego powodu niektórzy programiści nie lubią silników lub próbują pisać własne, w których używane są tylko potrzebne im komponenty ...

Ale ty i ja jesteśmy daleko od pracy-programistów :) Dlatego zacznijmy tworzyć prostą grę na Androida opartą na popularnym i potężnym silniku Unity3D.

Rozpoczęcie pracy z projektem w Unity3D

Dlaczego więc zdecydowaliśmy się na Unity3D:

• możliwość tworzenia pełnoprawnych gier 2D i 3D;
• możliwość skompilowania gotowej gry na dowolne urządzenie;
• względna łatwość sterowania silnikiem;
• dobra rozszerzalność funkcjonalności poprzez podłączenie wtyczek;
• stosunkowo niewielki rozmiar końcowego montażu gry (w porównaniu z innymi silnikami).

Głównym atutem Unity3D jest oczywiście jego wszechstronność i wieloplatformowość. Możesz przenieść gotową grę (prawdopodobnie z niewielkimi modyfikacjami), nawet na komputer PC (z systemem Windows, Linux lub MacOS), nawet na Androida, a nawet na PlayStation lub XBox! Aby to zrobić, musimy pobrać tylko sam silnik, który nawiasem mówiąc „waży” więcej niż gigabajt i niezbędne SDK (jeśli planowany jest rozwój na platformy mobilne lub konsole). Jeśli chcesz stworzyć grę dla systemu Windows, nie musisz niczego dodatkowo pobierać, ale ponieważ zamierzamy stworzyć grę na Androida, będziemy również musieli pobrać Android SDK (Software Development Kit). Radzę pobrać SDK w archiwum ZIP dla większej wygody w pracy z nim.

Po pobraniu wszystkiego możesz rozpakować go do dowolnego folderu Android SDK, który jest dla Ciebie wygodny, a następnie przystąpić do instalacji samego Unity3D. Jest instalowany jak każdy zwykły program pod Windows, więc nie powinno być problemów z instalacją. Po instalacji silnik się uruchomi i najpierw musimy stworzyć nowy projekt:

Aby to zrobić, będziemy musieli zamknąć wszystkie okna powitalne i wprowadzające, a następnie wybrać element „Nowy projekt” z menu „Plik”. W oknie, które się otworzy (patrz obrazek powyżej), zostaniemy poproszeni o wskazanie folderu do zapisania projektu (jego nazwa będzie się pokrywać z nazwą projektu), zaimportowanie niektórych standardowych zestawów funkcji (nie potrzebujemy ich) i wskazanie trybu działania. Wybierz tryb 2D i naciśnij przycisk „Utwórz”. To kończy prace przygotowawcze :)

Interfejs silnika i hierarchia projektów

Po utworzeniu projektu zostanie załadowany do przestrzeni roboczej Unity3D:

Sam obszar roboczy ma strukturę modułową i składa się z kilku zagnieżdżonych okien, które można dowolnie przesuwać. Mam to skonfigurowane w ten sposób (od lewej do prawej i od góry do dołu):

1. Okno Hierarchia - wyświetla hierarchiczną pozycję aktywnych i nieaktywnych obiektów na scenie. Domyślnie jedynym obiektem znajdującym się bezpośrednio na liście jest kamera główna.
2. Okno sceny - wyświetla całą scenę gry i znajdujące się na niej obiekty (w tym kamery, dźwięki, tekstury itp.).
3. Okno inspektora - wyświetla wszystkie właściwości obiektu wybranego w hierarchii lub na scenie i umożliwia ich edycję, uzupełnianie lub usuwanie.
4. Okno gry - wyświetla świat gry widziany przez kamerę i pozwala wybrać rozmiar wirtualnego okna gry testowej w pikselach. Pozwala również aktywować maksymalizację okna gry w pełnym rozmiarze (Maksymalizuj w grze) i włączyć / wyłączyć wyświetlanie różnych informacji dla dewelopera.
5. Okna projektu i konsoli. Okno Projekt służy do nawigacji po zasobach projektu: wczytanych obrazach, dźwiękach, modelach itp. Ponadto za pomocą tego okna (menu kontekstowego) możesz tworzyć nowe puste obiekty gry różnych typów i skryptów. Okno konsoli służy do wyświetlania komunikatów o błędach (kolor czerwony), ostrzeżeń (kolor żółty) i różnych żądanych informacji dotyczących debugowania (kolor szary).
6. Okno Etykieta zasobów - dolna część okna inspektora, w której wyświetlany jest podgląd obiektu lub pliku wybranego w oknie projektu.

Oprócz wszystkich powyższych zwróć uwagę na trzy przyciski w górnej środkowej części. Pozwalają na rozpoczęcie projektu, wstrzymanie (czasami przydatne podczas debugowania, na przykład, aby zobaczyć, co jest robione w hierarchii) i odpowiednio go wyłączyć.

Stworzymy symulator instrumentu muzycznego: indyjskie bębny ludowe o nazwie „tabla”, więc na początek utworzymy w projekcie dwa puste foldery, w których będą przechowywane dźwięki i obrazy. Nowy folder można utworzyć, wywołując menu kontekstowe w oknie nawigatora projektu i wybierając pozycję „Folder” z listy „Utwórz”.

Warto tutaj powiedzieć kilka słów o tym, jak nazwać te foldery. W przypadku prostej gry, takiej jak nasz symulator, w zasadzie foldery można „nazywać”, jak chcesz, jednak istnieją co najmniej dwie nazwy, których lepiej nie używać, ponieważ są one zarezerwowane przez silnik. To są nazwy Zasoby i Wtyczki. W dużych projektach folder Zasoby jest tworzony od razu i wszystkie „części zamienne” gry (obrazy, dźwięki, modele, tekstury i prefabrykaty) są w nim przechowywane (posortowane według podfolderów). Wtyczki, jak sama nazwa wskazuje, przechowują wszystkie dodatkowe zestawy funkcji innych firm (tak zwane „zasoby”), których jest całkiem sporo w Asset Store - sklepie z rozszerzeniami dla Unity3D.

Importowanie plików i tworzenie obiektów gry

Przed utworzeniem nowego projektu gry wskazane jest wcześniejsze przygotowanie wszystkich plików niezbędnych do jej działania. W naszym przypadku takimi plikami są obrazy i dźwięki. Najłatwiejszym sposobem zaimportowania ich do projektu jest po prostu przeciągnięcie i upuszczenie ich do żądanego folderu. Zacznijmy od zdjęć ...

Gdy obrazy pojawią się w naszym folderze Obrazy, należy je nieco poprawić:

Faktem jest, że domyślnie Unity3D kompresuje wszystkie obrazy dodane do projektu z utratą jakości. Jeśli nie potrzebujemy takiej straty (szczególnie ważne przy grach z grafiką HD), to powinniśmy zaznaczyć każdy obraz iw oknie Inspektora zmienić wartość parametru „Format” z „Skompresowany” na „Truecolor” w zakładce „Domyślne”. Może być również konieczna zmiana parametru „Maksymalny rozmiar”, jeśli jest on mniejszy niż rzeczywista szerokość obrazu (domyślnie - 1024 piksele). Po wszystkich zmianach nie zapomnij kliknąć przycisku „Zastosuj”, aby je zastosować. W razie potrzeby wykonaj podobne czynności dla wszystkich innych obrazów.

Teraz stwórzmy obiekty gry z naszych zdjęć. Aby to zrobić, po prostu przeciągnij żądany obraz do okna Hierarchia. Obraz lub model 3D zostanie automatycznie przekonwertowany na obiekt gry i wyświetlony na początku przed kamerą.

Przede wszystkim dodaliśmy obraz tła, który powinien być wyświetlany na pełnym ekranie. Możesz sprawdzić, czy tak jest, wybierając kamerę w oknie hierarchii i patrząc, jak jest wyświetlana jej ramka. Na powyższym zrzucie ekranu widać, że część naszego tła pozostaje poza widokiem kamery, dlatego należy dostosować rozmiar tego widoku, przeciągając ramkę w prawo na scenie lub edytując parametr „Rozmiar” w oknie Inspektora. W naszym przypadku musieliśmy zmienić domyślną wartość (5) na 5,4.

To wszystko, nie dotykamy już aparatu, ale dodajemy i dostosowujemy resztę zdjęć. Jak dodamy, widzimy, że niektóre z nich są za duże dla naszej gry. Można je zredukować fizycznie w edytorze graficznym lub za pomocą silnika. Wypróbujmy ostatnią metodę. Aby to zrobić, zaznacz obraz w oknie Hierarchia, aw oknie Inspector zmień wartości „Skala” dla współrzędnych X i Y z 1 na 0,5 (czyli zmniejszamy go o połowę). W tym samym miejscu, aby uniknąć nakładania się, pożądane jest przypisanie wszystkim obiektom gry (z wyjątkiem tła) niezerowej kolejności w warstwie:

Ostatnim krokiem w przygotowaniu obiektów do gry ze zdjęć jest „zawieszenie” na nich zderzaczy. W Unity3D zderzacze są używane jako detektory interakcji między obiektami. Oznacza to, że w rzeczywistości na naszym obrazie umieszczana jest wirtualna powłoka, która może zarejestrować jej dotknięcia.

Aby dodać collider do obiektu, należy zaznaczyć go w oknie Hierarchia, a następnie w oknie Inspector nacisnąć przycisk „Dodaj komponent”. Na liście komponentów, która się pojawi, szukamy Fizyki 2D (zwykła fizyka 3D nie będzie działać w naszym trybie) i tam ze wszystkich opcji najbardziej odpowiada nam "Circle Collider 2D". Wybieramy to. Wokół naszego obiektu pojawi się zielony kontur, który reprezentuje granice zderzacza. Pozostaje tylko zaznaczyć pole wyboru „Is Trigger”, aby nasz collider rejestrował tylko kliknięcia i nie wchodził już w interakcję z otaczającą przestrzenią gry:

Powtarzamy podobne czynności dla wszystkich pozostałych obiektów. Jedynie nasze tło będzie się różniło od innych obiektów. W tym celu użyjemy Box Collider 2D i ustawimy Position Z na więcej niż zero, aby przesunąć zderzacz i samo tło na tło (przyda się to trochę później).

Praca z dźwiękiem

Dźwięk w Unity 3D na pierwszy rzut oka wydaje się nieco zagmatwany. Ale spróbujmy to rozgryźć po kolei :)

Pierwszą rzeczą, którą musimy zrobić, to przeciągnąć wszystkie dźwięki do folderu Dźwięki i trochę je poprawić:

Jeśli poziom głośności wszystkich dźwięków jest wstępnie dostosowany, wystarczy wyłączyć przetwarzanie dźwięku 3D. W grach 3D przetwarzanie to jest potrzebne do symulacji zbliżania się źródła dźwięku, gdy zbliża się do niego kamera. Ale w 2D nie jest to potrzebne, więc po kolei wybieramy każdy dźwięk i odznaczamy pole wyboru „Dźwięk 3D”.

Teraz możemy zacząć dodawać dźwięki do obiektów w grze. Aby to zrobić, musimy po kolei zaznaczyć każdy przycisk i dodać do niego nowy komponent „Audio Source” z sekcji „Audio”. Po dodaniu komponentu wybierz odpowiedni przycisk „Klip audio” i usuń zaznaczenie pola wyboru „Odtwarzaj po przebudzeniu” (domyślnie aktywne):

Kiedy wszystkie dźwięki zostaną przypisane do żądanych przycisków, czas na zabawną część - tworzenie skryptów ...

Pierwszy scenariusz

Zanim zaczniemy analizować nasz pierwszy skrypt, warto chyba powiedzieć kilka słów o samym systemie skryptów w Unity 3D.

Unity umożliwia pisanie kodu w trzech językach naraz: JavaScript (a dokładniej jego nieco zmodyfikowana wersja UnityScript), C # i Boo. W wielu książkach i samouczkach można znaleźć opinię, że początkującym łatwiej jest nauczyć się obsługi skryptów w Unity na przykładzie JavaScript. Jednak ten język nie jest tak przyjazny dla użytkownika jak inne iw przyszłości najprawdopodobniej będziesz musiał się uczyć od nowa. Dlatego lepiej zacząć od razu od nauki języka C # (Boo też nie jest zły, ale samouczków na jego temat jest niewiele).

Teraz o tym, gdzie napisać kod. Domyślnym edytorem kodu w Unity 3D jest MonoDevelop IDE. Zaletą tego środowiska programistycznego jest to, że zawiera wskazówki dotyczące szybkiego wprowadzania standardowych metod, klas i funkcji, a także system sprawdzania składni. Jednak dla mnie wadą była nieporęczność i duże wykorzystanie zasobów. Na szczęście w ustawieniach Unity można ustawić cokolwiek jako edytor tekstu, więc „zawiesiłem” dla siebie lekki i funkcjonalny Notepad ++ (prawie wszystkie przykłady zostaną w nim pokazane).

I ostatnia rzecz. Oczywiście nie zajdziesz daleko bez materiałów referencyjnych w opanowaniu wszystkich zawiłości silnika, więc oto lista kilku sensownych zasobów internetowych na temat Unity 3D:

• http://docs.unity3d.com/ru/current/Manual/UnityManualRestructured.html - oficjalna instrukcja silnika z częściowym tłumaczeniem na język rosyjski (pojawiła się niedawno i na razie czasami jest niestabilna);
• http://docs.unity3d.com/ru/current/ScriptReference/index.html - oficjalny podręcznik skryptów w języku angielskim;
• http://unity3d.ru/distribution/index.php - rosyjskojęzyczne forum dla programistów Unity 3D;
• http://habrahabr.ru/post/141362/ - cykl lekcji na temat tworzenia trójwymiarowych gier na Habrahabr;
• http://msdn.microsoft.com/ru-ru/library/618ayhy6.aspx - oficjalne odniesienie do języka C # firmy Microsoft w języku rosyjskim.

Cóż, aby nie zwlekać długo, proponuję od razu stworzyć pierwszy skrypt. W przypadku skryptów, jeśli jest ich wiele, lepiej wybrać osobny folder, ale nasza gra będzie prosta, więc możemy stworzyć skrypt bezpośrednio w głównym folderze projektu. Aby to zrobić, wywołaj menu kontekstowe w oknie projektu, wybierz listę Utwórz i kliknij „C # Script”. Nazwijmy nasz nowy skrypt, na przykład Dźwięki i otwórzmy go podwójnym kliknięciem. Po usunięciu standardowych metod Update i Start, a następnie po zarejestrowaniu niezbędnych otrzymujemy następujący typ skryptu:

Jeśli nie zmieniłeś konfiguracji edytora, nasz skrypt otworzy się w MonoDevelop. Przeanalizujmy jego strukturę ...

W rzeczywistości każdy skrypt C # składa się z trzech głównych części:

1. Na samej górze znajdują się biblioteki, które trzeba podłączyć, aby skrypt działał (np. „Using Unity.Engine” łączy sam silnik, a „using System.Collections” - biblioteka zawierająca szereg wbudowanych klas, aby skrypt działał w różnych systemach).
2. Deklaracje klas i zmiennych. W C # nie ma koncepcji skryptu jako takiego. Zamiast tego używane jest pojęcie „klasy”, które obejmuje szereg metod i funkcji. Chociaż w rzeczywistości w kontekście Unity 3D jest prawie tak samo :) Najważniejsze do zapamiętania jest to, że nazwa klasy musi odpowiadać nazwie, którą nadaliśmy skryptowi. Osobliwością zmiennych w C # jest to, że muszą być wpisywane (z wyjątkiem tymczasowych, które są zadeklarowane w samym skrypcie). W praktyce oznacza to, że dla zmiennej należy określić poziom dostępu (prywatny lub publiczny) i typ (int, float, bool lub, jak w naszym skrypcie, AudioClip). W takim przypadku można nadać zmiennej dowolną nazwę lub od razu nadać jej wartość przypisać.
3. Zestaw metod i funkcji. Prawie każda funkcja, która wykonuje określoną akcję, jest nazywana metodą w C #. Zasadniczo w literaturze na temat Unity 3D nazywane są funkcjami, ale jeśli mówimy o C # jako odrębnym języku programowania, to są to metody :). Funkcje w czystej postaci w Unity to na przykład standardowe funkcje wyjścia dźwięku, renderowania elementów GUI itp., Które są używane w metodach.

Znając już strukturę skryptu, łatwo jest zrozumieć jego znaczenie, które sprowadza się do następujących ... W klasie Sounds (skrypt) deklarujemy 9 zmiennych typu AudioClip o nazwach potrzebnych nam dla wygody ich rozróżnienia. Musimy je koniecznie uczynić publicznymi (prywatne nie będą wyświetlane w edytorze i będziemy musieli „zawiesić” na nich dźwięki w edytorze). Następnie w treści skryptu używamy standardowej metody "void OnMouseDown ()". Wcześniej odpowiadał tylko za obsługę kliknięcia myszą, ale w nowszych wersjach jest również interpretowany jako dotknięcie ekranu dotykowego. Piszemy w nim warunki, według których sprawdzamy nazwy wciśniętych zderzaczy i jeśli wykryjemy wciśnięcie jednego z nich, wyprowadzamy odpowiedni dźwięk (używamy standardowej funkcji audio.PlayOneShot ();).

Pisząc kod uważnie monitoruj obecność wszystkich nawiasów otwierających i zamykających, w przeciwnym razie będziesz ciągle otrzymywać raporty o błędach w Konsoli i nie będziesz mógł w ogóle uruchomić swojego projektu! Zwróć także uwagę na użycie wielkich liter w nazwach metod i funkcji. Często są też przyczyną błędów. I oczywiście przestrzegaj wszystkich znaków (kropek, dwukropków i nawiasów), krótko mówiąc, składni języka. Na początku będzie to trudne, ale z czasem zaczniesz pisać od zera bez błędów!

Gdy skrypt będzie gotowy, wybierz go i przypisz dźwięk do każdej zmiennej w oknie Inspektora. Teraz musimy tylko zastosować nasz skrypt do obiektów na scenie. Najłatwiej to zrobić ponownie, przeciągając skrypt bezpośrednio do żądanego obiektu gry na liście Hierarchia:

Jeśli skrypt został poprawnie przeciągnięty i upuszczony, to powinien pojawić się w oknie Inspektora obiektu, do którego go przeciągnęliśmy. W związku z tym przeciągamy skrypt na wszystkie obiekty, które powinny brzmieć w grze i możemy spróbować go uruchomić. Po kliknięciu naszych przycisków do gry w końcu zabrzmi wstępnie ustawiony dźwięk!

Wprowadzenie do GUI

W zasadzie Gra już dla nas działa, ale jakoś jest zbyt „łysa”. Czegoś w nim brakuje ... A przynajmniej napis z nazwą tego, co przed nami! Innymi słowy, musisz zaimplementować jakiś spójny interfejs użytkownika.

Właściwie GUI to skrót od angielskiego. „Graficzny interfejs użytkownika”, czyli graficzny interfejs użytkownika. Tradycyjnie zawiera takie elementy jak:

• guziki;
• okno;
• obszary tekstowe;
• pola wyboru i / lub przyciski radiowe;
• suwaki (paski przewijania) itp.

W Unity 3D Wszystko to (a nawet więcej) jest w pełni obecne. Najważniejsze, aby nauczyć się go używać! Zastanówmy się, jak za pomocą GUI w Unity można stworzyć prostą etykietę tytułową.

Aby to zrobić, utwórz nowy skrypt o nazwie Interfejs i zmień go w następujący sposób:

Przyjrzyjmy się bliżej skryptowi na zrzucie ekranu. Tutaj piszemy dla nas tylko jedną zmienną publiczną nowego typu GUIStyle. Ten typ umożliwia wizualną zmianę wyglądu elementów, do których przypisany jest ten styl. Style są przydatne, gdy istnieje wiele elementów interfejsu tego samego typu (na przykład przyciski), ale muszą one mieć inny wygląd.

Następnie tworzymy przycisk ("GUI.Button"), który ma następującą składnię: warunek - 4 współrzędne (poziome odsunięcie od lewej krawędzi, pionowe odsunięcie od górnej krawędzi, szerokość, wysokość) - widoczny tekst w cudzysłowie i dalej, opcjonalnie, wskazanie stylu. Wymagane funkcje są zapisane w warunku przycisku. W naszym przypadku zarejestrowaliśmy przejście do witryny deweloperów („Application.OpenURL („ ”);”).

Skrypty GUI mogą działać z dowolnego obiektu gry, ale zwykle zaleca się, aby "zawiesiły się" na kamerze, co zrobimy przeciągając skrypt na obiekt kamery głównej. Teraz, jeśli wybierzesz ją w oknie Hierarchia, to w oknie Inspektora będziemy mogli zobaczyć zmienną publiczną naszego stylu, po rozwinięciu której uzyskamy pełny dostęp do ustawień tego stylu!

Możemy określić kolor tekstu i teksturę tła w dowolnych sytuacjach (dla przycisku należy zarejestrować trzy jego warianty (Normalny - widok normalny, Najechanie - po najechaniu i Aktywny - po kliknięciu), ustawić wcięcia oraz ustawić czcionkę. Domyślnie jedyna dostępna w Unity 3D czcionka to Arial, ale możesz ręcznie wczytać dowolną inną do projektu i zastosować ją w polu „Czcionka”, dostosowując wszystkie powiązane parametry.

Co ciekawe, a jednocześnie niezbyt wygodne, elementy GUI nie są wyświetlane na scenie, dopóki nie uruchomimy projektu, więc dostosowanie parametrów każdego elementu może zająć dużo czasu. Zacznijmy projekt i zobaczmy, jak będzie wyglądał nasz utworzony powyżej przycisk:

Modyfikowanie interfejsu według warunku i zmiennych statycznych

Zrobiliśmy już wiele, ale zawsze jest miejsce na ulepszenia :) Dlatego jako ostatni przykład proponuję stworzenie okna pomocy, za pomocą którego zwykli programiści zwykle udostępniają swoje gry i aplikacje. Aby to zrobić, dodaj zdjęcie takiego przycisku w postaci znaku zapytania do folderu z obrazami i utwórz z niego obiekt gry. Zawieśmy na nim zderzacz i napiszmy skrypt z nazwą, na przykład „Pomoc” o następującej treści:

W tym skrypcie mamy dwie zmienne. Pierwsza zmienna definiuje karnację, która będzie używana dla wszystkich elementów interfejsu opisanych w tej klasie. W przeciwieństwie do stylów, które omówiliśmy powyżej, skórki pozwalają na zmianę wyglądu nie tylko pojedynczego elementu, do którego są przypisane, ale wszystkich elementów określonego typu jednocześnie. Ponadto, w przeciwieństwie do stylów, skórki nie są przypisywane do elementów, ale są deklarowane dla całej metody naraz i działają do momentu zadeklarowania innej karnacji. Należy również pamiętać, że skórki istnieją nie tylko jako zmienne, ale także jako osobne pliki. Dlatego przed zadeklarowaniem skórki należy ją od razu utworzyć w oknie „Projekt” z menu kontekstowego: „Utwórz” - „Skórka GUI”.

Druga zmienna jest logiczna (inaczej mówiąc logiczna). Może mieć tylko dwie wartości: „prawda” (prawda) lub „fałsz” (fałsz). Taka zmienna ze względu na swój binarny charakter doskonale nadaje się do implementacji wszelkiego rodzaju przełączników. W naszym przypadku będzie on odpowiedzialny za wyświetlanie tekstu opisującego naszą grę.

Jeśli jednak przyjrzysz się uważnie, zauważysz, że ostatnia zmienna ma jeden wspaniały parametr - „statyczny”. Dodanie takiego parametru do zmiennych pozwala uczynić je statycznymi i uzyskać do nich dostęp z innych skryptów!

Ale wracając do reszty kodu. Znana nam już metoda „void OnMouseDown ()” posłuży tutaj jako przełącznik dla zmiennej „isVisible” przy użyciu prostego warunku. Jednak po warunku jest jeszcze jedna funkcja. Ta funkcja ("Debug.Log ();") służy do wyświetlania w locie wartości potrzebnych nam zmiennych do konsoli (wpisujemy je bez cudzysłowów w nawiasach). Jak widać, wewnątrz funkcji można łączyć zarówno niezmienny tekst (zapisany w cudzysłowie), jak i zmienne (bez cudzysłowów). Najważniejsze jest to, że między wszystkimi danymi znajduje się znak „+”.

W dalszej części skryptu mamy metodę rysowania interfejsu ("void OnGUI () ()"), wewnątrz której widzimy deklarację nowej skórki ("GUI.skin \u003d HelpSkin;") oraz nowy element interfejsu typu GUI.Box. W przeciwieństwie do przycisku, ramka jest elementem nieaktywnym i jest zwykle używana do wyświetlania różnych danych tekstowych lub graficznych.

Zwróć uwagę, jak umieściliśmy pudełko. Tutaj wszystkie wartości nie są podawane bezpośrednio, ale przy użyciu wyrażeń matematycznych, co w rzeczywistości jest analogiczne do „płynnego układu” w tworzeniu stron internetowych. Problem polega na tym, że podczas określania dokładnych rozmiarów elementów GUI przy różnych rozdzielczościach ekranu, nie dostosują się one i mogą być albo za małe, albo odwrotnie, duże. W kolejnej wersji silnika programiści obiecują, że GUI będzie responsywne, ale na razie musimy się wypaczyć :(

Ostatnim krokiem na drodze do sukcesu będzie dostosowanie naszej skóry. Określ plik karnacji w zmiennej skryptu, a następnie wybierz ten plik w oknie projektu. Podobnie jak w przypadku innych plików, ustawienia skórki zostaną wyświetlone w oknie Inspektora. Tutaj szukamy elementu, który podlega zmianie (w naszym przypadku Box), rozwijamy go i konfigurujemy analogicznie do stylu omówionego powyżej:

Aby sprawdzić, czy nasz skrypt działa poprawnie, uruchommy projekt i spróbujmy kliknąć przycisk pomocy:

Teraz wszystko działa, ale nie zawsze wygodnie jest nacisnąć przycisk pomocy, aby ukryć opis z powrotem. Bardziej zwyczajem jest zagłębianie wolnego miejsca w celu zniknięcia powiadomień niż celowanie w przyciski. I tutaj wystarczy, że zmieniliśmy statyczną zmienną „isVisible”, a zderzacz zawieszony na obrazie tła ...

Wróćmy do naszego pierwszego skryptu („Dźwięki”), który śledził kliknięcia przycisków, aby odtwarzać dźwięki. W nim (a dokładniej wewnątrz metody "void OnMouseDown ()") wystarczy napisać tylko jedną linię:

if (this.name! \u003d "HelpButton") (Help.isVisible \u003d false;)

Tą linią ustawiamy warunek: jeśli nazwa wciśniętego collidera nie jest równa nazwie przycisku pomocy, to zmienna „isVisible” w skrypcie „Help” będzie równa „false”. Potrzebujesz tylko zmiennej "isVisible", aby mieć "statyczny" postscript, w przeciwnym razie pojawi się błąd.

Teraz po uruchomieniu zobaczymy, że nasze okno pomocy zamyka się, gdy klikniemy nie tylko przycisk w prawym górnym rogu, ale także gdy dotkniemy dowolnej wolnej części ekranu. Jedyne, co można jeszcze poprawić, to ukryć okno i klikając je ... To będzie twoja "praca domowa";) Powiem tylko, że okno GUI będzie musiało zostać zmienione na podobnie zaprojektowany przycisk, ponownie z ustawieniem skin i przypisanie funkcji zmieniającej zmienną „isVisible”. To wszystko, będę cicho :)

Kompilowanie gry i zapisywanie projektu

Wreszcie wszystko u nas działa! Oznacza to, że czas zapisać naszą grę i przetestować ją na prawdziwym urządzeniu. Aby to zrobić, należy go skompilować do pliku wykonywalnego (dla systemu Windows, na przykład w formacie EXE, a dla systemu Android w pakiecie APK).

Jeśli chcesz skompilować grę na PC, nie musisz dokonywać żadnych wstępnych ustawień. Jednak w przypadku Androida musisz najpierw podłączyć zestaw Android SDK, który pobraliśmy na samym początku. Robi się to po prostu: przejdź do menu „Edycja”, wywołaj element „Preferencje” iw oknie, które zostanie otwarte, przejdź do zakładki „Narzędzia zewnętrzne”. W tym miejscu szukamy linii „Android SDK Location” i określamy w niej ścieżkę do rozpakowanego archiwum z SDK (patrz zrzut ekranu poniżej). Swoją drogą, tutaj możesz także zmienić domyślny aktywny monstrualny edytor tekstu MonoDevelop na swój ulubiony :)

A teraz nadeszła chwila prawdy! Przejdź do menu „Plik” i poszukaj elementu „Ustawienia kompilacji”. W oknie, które zostanie otwarte, będziemy musieli natychmiast dodać sceny do złożenia. Jeśli jest tylko jedna scena (jak w naszym projekcie), wystarczy wcisnąć przycisk „Dodaj aktualną”. Jeśli jest ich kilka, będziesz musiał otworzyć każdą z nich i dodać je do listy scen w ten sam sposób, a następnie, przeciągając i upuszczając, skonfiguruj żądaną sekwencję:

Kolejnym krokiem jest wybranie platformy do budowania (planujemy grę na Androida, co oznacza, że \u200b\u200bją wybieramy) i wciśnięcie przycisku „Ustawienia gracza” poniżej. W oknie Inspektora otworzy się wiele ustawień, z których niektóre są wymagane lub bardzo pożądane. Pożądane jest wskazanie nazwy firmy deweloperskiej, programu i jego ikon (odpowiednio Nazwa firmy, Nazwa produktu i Ikona domyślna) u góry listy ustawień.

U dołu, w sekcji „Inne ustawienia”, znajdują się dwa wymagane parametry: „Identyfikator pakietu” i „Wersja pakietu”. Domyślną wersją jest 1.0, ale identyfikator będzie musiał zostać utworzony ręcznie i najlepiej unikatowy. Powinien składać się z trzech części oddzielonych od siebie kropkami: słowo zastrzeżone „com”, następnie nazwa firmy deweloperskiej, a na końcu nazwa samej aplikacji.

Możesz zmienić pozostałe ustawienia zespołu według własnego uznania lub nie zmieniać ich wcale. Najważniejsze jest to, że teraz kompilacja może już się rozpocząć. Aby to zrobić, wystarczy nacisnąć przycisk „Build” w oknie „Build Settings” i poczekać, aż programy podadzą nam gotową aplikację spakowaną w plik APK :)

Wniosek

Na tym kończy się nasza lekcja na temat tworzenia najprostszych aplikacji na Androida. Abyś mógł powtórzyć wszystko, o czym rozmawialiśmy, na końcu artykułu podam link do archiwum, w którym wszystkie zasoby gry będą przechowywane w postaci osobnego folderu (jeśli chcesz zrobić wszystko od zera) oraz jako plik z rozszerzeniem unitypackage. Ta ostatnia pozwala na zaimportowanie całego projektu do Unity naraz, w tym zależności itp.

Aby zaimportować nasz projekt (a przy okazji wszelkie wtyczki pobrane z internetu lub ze Sklepu Zasobów) należy wejść w menu „Zasoby”, wybrać element „Importuj pakiet”, aw nim „Pakiet niestandardowy”, następnie podać ścieżkę do naszego pliku i kliknij przycisk „Importuj”. Nawiasem mówiąc, możesz wykonać pełną kopię zapasową projektu, zapisując w takim pakiecie jednostkowym, z tego samego menu („Zasoby”), klikając element „Eksportuj pakiet”.

Wygląda na to, że wszystko :) Jako osoba, która sama opanowała Unity 3D od podstaw, w artykule starałem się udzielić odpowiedzi na maksymalną liczbę pytań i wskazać główne niuanse pracy z silnikiem, które pojawiają się na początku. Ale być może komuś to nie wystarczy, więc jeśli masz jakieś pytania, możesz skontaktować się ze mną bezpośrednio przez e-mail lub na forum: pomogę Ci tak bardzo, jak tylko będę mógł!

Życzę wszystkim powodzenia i udanej realizacji wszystkich projektów!

P.S. Dozwolone jest dowolne kopiowanie i cytowanie tego artykułu pod warunkiem wskazania otwartego aktywnego linku do źródła i zachowania autorstwa Ruslana Tertyshnego.