WWpprroowwaaddzzeenniiee ddooo o pprrrooggg ......Jakub Klementewicz uczeo kl. Ib I Liceum...
Transcript of WWpprroowwaaddzzeenniiee ddooo o pprrrooggg ......Jakub Klementewicz uczeo kl. Ib I Liceum...
WWWppprrrooowwwaaadddzzzeeennniiieee
dddooo ppprrrooogggrrraaammmooowwwaaannniiiaaa gggiiieeerrr
kkkooommmpppuuuttteeerrrooowwwyyyccchhh
www śśśrrrooodddooowwwiiissskkkuuu UUUnnniiitttyyy
Jakub Klementewicz
uczeo kl. Ib
I Liceum Ogólnokształcącego
w Radzyniu Podlaskim
Radzyo Podlaski grudzieo 2015
2
Spis treści
Temat 1. Czym jest Unity? ......................................................................................................... 3
Potężne narzędzie dla twórców .............................................................................................. 3
Wersje Unity ........................................................................................................................... 3
Asset Store .............................................................................................................................. 3
Temat 2. Interfejs Unity ............................................................................................................. 4
Interfejs Unity ......................................................................................................................... 4
Temat 3. Możliwości Unity ........................................................................................................ 5
Najbardziej znane gry utworzone w Unity ............................................................................. 5
Temat 4. Historia gry ................................................................................................................. 7
Po co nam historia gry? .......................................................................................................... 7
Historia gry BlueCube ............................................................................................................ 7
Temat 5. Rozpoczynamy pracę .................................................................................................. 8
Przygotowania ........................................................................................................................ 8
Uruchamianie Unity i tworzenie nowego projektu ................................................................. 8
Rozpoczynamy pracę – do dzieła! .......................................................................................... 8
Tworzenie obiektów ............................................................................................................... 9
Tworzenie folderu i kolorowanie obiektu ............................................................................ 10
Dodawanie niezbędnych do ruchu komponentów ................................................................ 10
Dodawanie „Rigidbody” do obiektu ..................................................................................... 11
Temat 6. Programowanie ruchu i zbierania ............................................................................. 11
Przygotowanie ...................................................................................................................... 11
Wstęp do programowania ..................................................................................................... 12
Zmienne ................................................................................................................................ 13
Funkcje ................................................................................................................................. 14
Programowanie ruchu w Unity ............................................................................................. 15
Zbieranie punktów ................................................................................................................ 16
Temat 7. Tworzenie punktów ................................................................................................... 20
Tworzenie punktu ................................................................................................................. 20
3
Temat 1. Czym jest Unity?
Potężne narzędzie dla twórców Unity jest zbiorem narzędzi dającym ogromne możliwości nawet niezależnym,
początkującym twórcom. Ze swojego założenia ma być dostępne dla jak największej rzeszy
pasjonatów kreatywnego posługiwania się komputerem. Posiada prosty i intuicyjny interfejs
zawierający szeroką gamę opcji i narzędzi edycyjnych. Na stronie produktu zamieszczono
wiele poradników (tutoriali) tekstowych połączonych z materiałami wideo objaśniającymi
zasady posługiwania się Unity oraz instruktażami dotyczącymi programowania w tym
środowisku.
Językami dopuszczanymi w Unity są JavaScript i C#. Wydawca zaleca używanie C#.
Dodatkowym aspektem przemawiającym za wyborem Unity jest możliwość tworzenia
programów na systemów operacyjnych. Produkty utworzone dla komputerów PC, mogą
zostać łatwo przekonwertowane do środowiska Mac, Android itp.
Wersje Unity Unity udostępniane jest w dwóch wersjach, „Unity” i „Unity Pro”. Wersja „Unity”
umożliwia tworzenie w pełni funkcjonalnych programów komputerowych, w tym również
gier, które potem możemy wykorzystywać w celach zarobkowych, dopóki nie zarobimy w
ciągu jednego roku fiskalnego 100 000$1. Zezwala to na rozwinięcie swojej działalności przez
każdego, bez obaw czy jego produkty osiągną odpowiednią popularność. Gdy zostanie
przekroczony próg wyżej wymienionej kwoty, twórca jest zmuszony zakupić wersję „Pro”.
Oprócz spełnienia wymogu licencji oferuje ona nam pomoc techniczną ze strony wydawcy
oraz wiele nowych narzędzi testowych.
Asset Store Asset Store – sklep internetowy zarządzany przez wydawcę Unity w którym możemy
znaleźć wiele ciekawych prac innych użytkowników(twórców), które możemy w pełni
legalnie wykorzystywać w naszych projektach, nawet komercyjnych. Niektórzy z prywatnych
twórców danego produktu jakim może być np. model, ścieżka dźwiękowa czy skrypt żądają
również umieszczenia ich imienia i nazwiska lub nick’u w naszym produkcie.
1 https://unity3d.com/legal/eula
4
Temat 2. Interfejs Unity
Interfejs Unity
Rysunek 1. docs.Unity.com
Został on zaprojektowany tak, aby był intuicyjny i prosty w użyciu. Składa się
z czterech podstawowych części:
Toolbar –pasek narzędziowy; znajdują się tam najważniejsze narzędzia oraz pola
dotyczące obsługi sceny;
Hierarchy – pole w którym widzimy hierarchię obiektów naszego projektu; staranne
nazewnictwo obiektów jest bardzo ważne dla całego projektu, zarówno od strony
komfortu dla programisty, jak i optymalizacji;
Project –hierarchia folderów oraz plików dołączonych do projektu, bądź w nim
utworzonych; tutaj również ściśle obowiązuje zasada poprawnego nazewnictwa;
Inspector – zawarte są w nim wszystkie parametry dotyczące danego obiektu, takie
jak jego pozycja czy dołączone komponenty.
Scene – najważniejsze pole w Unity. dzięki niej możemy w prosty sposób zarządzać
pozycją i ustawieniem wszystkich obiektów na scenie, czyli miejscu w którym będzie
rozgrywała się akcja całego programu.
5
Temat 3. Możliwości Unity
Najbardziej znane gry utworzone w Unity
Unturned
Gra survivalowa utworzona przez 17-letniego Kanadyjczyka Nelsona Sextona,
w której gracz wciela się w postać survivalowca, próbującego przetrwać podczas apokalipsy
Zombie. Opracowana i zrealizowana przez niego w ciągu jednego roku, wciąż rozwijana.
Pomimo swojej prostej voxelowej grafiki, osiągnęła status jednej z najpopularniejszych gier
w serwisie Steam. W ciągu niespełna roku pobrano ją około 13 milionów razy.
Rysunek 2. Kadr pobrano z: http://unturned.pl/lowienie-ryb/
Rysunek 3. Kadr pobrano z: http://unturned.pl/nowa-mapa-washington/
6
Rust
Gra osadzona w czasach teraźniejszych utworzona przez studio Facepunch. Gracz
wciela się w rolę rozbitka, błąkającego się po wyspie. Jego zadaniem jest zdobycie surowców
na utworzenie narzędzi, budowa bazy i konkurowanie z innymi przeciwnikami. Jak możemy
poniżej zobaczyć Unity zezwala na tworzenie naprawdę fantastycznej grafiki, niewiele już
odbiegającej od świata realnego.
Rysunek 4. madewith.unity.com/games/rust
Rysunek 5. madewith.unity.com/games/rust
Rysunek 6. madewith.unity.com/games/rust
7
Temat 4. Historia gry
Po co nam historia gry? Wcześniejsze przygotowanie planu i opisanie gry jest istotnym elementem
w powstawaniu gry. Historia nie musi być czymś wielkim. Może to być jedno zdanie:
„Wyobraź sobie, że masz niebieski sześcian, który zbiera żółte o wiele mniejsze sześciany.”
lub wielostronicowy folder z najrozmaitszymi opisami dotyczącymi każdego detalu gry,
z załączonymi wstępnymi szkicami, scenariuszem itp. Jedno proste zdanie nakreśla już
pewien obraz gry, ale dla dobrego i szanującego się twórcy to za mało! Wybierzmy coś
pośredniego.
Historia gry BlueCube Pierwszym krokiem jaki powinniśmy podjąć jest stworzenie krótkiego opisu słownego
naszej gry. W naszym wypadku będzie to:
„W grze BlueCube gracz zasiada za sterami niebieskiego sześcianu. Jego zadaniem
jest poruszanie się wyżej wymienionym obiektem za pomocą klawiszy WASD i zbieranie
małych żółtych sześcianów. Za każdy zebrany sześcian gracz otrzymuje jeden punkt”.
Gdy mamy już jasno określony cel możemy przejść do opisu punktowego:
Tytuł: BlueCube;
Cel: Zdobycie dziesięciu punktów poprzez zbieranie żółtych sześcianów; jeden
sześcian – jeden punkt;
Gracz: niebieski sześcian;
Sterowanie: za pomocą klawiszy WASD;.
Choć może wydawać się, że w tak małych projektach jest to zbędne, ponieważ
wszystkie te informacje bez większego trudu jesteśmy w stanie zapamiętać. Zaleca się
tworzenie historii gry zawsze! Uczy to bardzo dobrego i przydatnego nawyku, który wraz ze
zwiększeniem ilości tworzonych projektów, będzie owocował łatwiejszym i bardziej
efektywnym realizowaniem gry.
8
Temat 5. Rozpoczynamy pracę
Przygotowania Aby rozpocząć pracę z Unity należy:
1. Mieć chęci rozpoczęcia pracy z Unity
2. Mieć w pełni gotowy, przemyślany plan produktu jaki chcemy stworzyć.
3. Mieć darmową wersję „Unity Personal”.
4. Uważnie, dokładnie i starannie postępować zgodnie z moimi instrukcjami.
Uruchamianie Unity i tworzenie nowego projektu
Po uruchomieniu programu pojawia się wyżej zaprezentowane okno. W tym
momencie musimy zdecydować się czy nasza gra będzie realizowana w wymiarze 2D czy 3D.
Na potrzeby prezentacji wybieramy tryb 3D. Ciekawostką, którą warto w tym miejscu dodać
jest to, iż gry 2D mogą być bez problemu tworzone w trybie 3D, aczkolwiek jest to mniej
wydajne rozwiązanie.
W polu „Project name” wpisujemy nazwę naszego projektu;
Location – ścieżka do folderu gdzie będą przechowywane pliki naszego projektu.
Nasz projekt nazwiemy „Kurs-Cube”. Po wciśnięciu przycisku „Create Project”
program uruchamia się z załadowanym nowym, pustym projektem.
Rozpoczynamy pracę – do dzieła! Skoro umiemy już tworzyć nowy projekt i bez większych problemów uruchomić
Unity, czas na postawienie poprzeczki o jeden stopień wyżej. Zapoznamy się już „na żywo”
z interfejsem Unity. Po uruchomieniu programu powinniśmy ujrzeć następujący obraz:
9
Jak możemy zauważyć w polu „Hierarchy” znajdują się dwa obiekty:
Main Camera, czyli kamera główna, która oznaczona jest na scenie
charakterystycznym, dobrze znanym symbolem kamery ze szpulami taśmy; od jej
ustawienia zależy to co będzie widoczne dla gracza.
Directional Light, czyli światło kierunkowe, oznaczone na scenie za pomocą „małego
słoneczka”; od ustawień tego obiektu będzie zależeć wiele ważnych czynników m.in.
jasność, kolor światła, jego nasycenie itp.
Tworzenie obiektów Pierwszym zadaniem będzie utworzenie planszy oraz niebieskiego sześcianu, czyli
modelu reprezentującego naszego gracza. Aby tego dokonać należy kliknąć prawym
przyciskiem myszy w polu „Hierarchy”, a następnie z rozwijanego menu wybrać „3D
Object” -> Plane.
W efekcie powinniśmy ujrzeć biały prostokąt w polu „Scene” oraz obiekt o nazwie
„Plane” w „Hierarchy”.
Kolejnym krokiem jest utworzenie sześcianu a następnie nałożenie na niego
niebieskiego koloru. Analogicznie do poprzedniego dodawania modelu klikamy prawym
przyciskiem myszy w „Hierarchy”, lecz tym razem klikamy 3D Object -> Cube. Powinniśmy
ujrzeć na naszym ekranie model sześcianu widoczny w połowie. Jego pierwsza(widoczna)
część znajduje się nad płaszczyzna podłogi, natomiast druga(niewidoczna) przenika przez nią
i znajduje się pod spodem. Wynika to z tego, iż pozycja każdego z modeli w Unity jest
reprezentowana za pomocą trzech zmiennych układu kartezjańskiego XYZ. Domyślnie są one
ustawiane w pozycji 0,0,0. Skoro nasza plansza ustawiła się w pozycji 0,0,0 , a to samo
10
uczynił również sześcian oznacza to że ich środki są punktami zerowymi dla trzech
zmiennych z tego układu. Jeśli nasz sześcian ma domyślne wymiary 1x1x1, a my widzimy, że
odwołując się do jego wysokości, dostrzegamy go tylko w połowie, należy zmienić jego
początkową pozycję o 0,5 względem osi Y. Aby tego dokonać, klikamy na sześcian i w polu
„Inspector” zmieniamy wartość „Position Y” w komponencie Transform z 0 na 0,5.
Jak widzimy nasz sześcian jest teraz w pełni widoczny. Czas na nałożenie na niego
odpowiedniego koloru, odróżniającego go od podłoża.
Tworzenie folderu i kolorowanie obiektu W polu „Project” w zakładce „Assets” należy kliknąć prawy przycisk myszy, wybrać
opcję Create->Folder. Nazwijmy go Materiały. Następnie po wejściu do folderu należy
ponownie kliknąć Create, lecz tym razem w rozwijanym menu wybrać opcję „Material”.
Świeżo utworzony Materiał nazwijmy „KolorGracza”.
Spośród wszystkich dostępnych tutaj pól
edycyjnych dla nas najważniejsze jest pierwsze
pole o nazwie „Albedo”. Aby zmienić kolor tego
materiału należy kliknąć w biały prostokąt.
Następnie z tarczy kolorów trzeba wybrać
interesujący nas kolor. W naszym wypadku
będzie to kolor niebieski. Nakładanie materiału na
sześcian jest bardzo proste – wystarczy
przeciągnąć ikonę materiału z pola „Project” na
obiekt na scenie, któremu chcemy przypisać ten
dany kolor.
Dodawanie niezbędnych do ruchu komponentów Aby móc poruszać naszym sześcianem, niezbędne jest dodanie komponentu
„Rigidbody” odpowiadającego za wszelakie automatyczne obliczenia dotyczące fizyki ruchu.
Nie oznacza to jednak, ze wszystko zrobi się samo. Komponenty nas wspomagają, nie
wykonają za nas pracy!.
11
Dodawanie „Rigidbody” do obiektu
Należy zaznaczyć niebieski sześcian klikając na nim w polu „Scene”, bądź wybierając
nazwę „Cube” z „Hierarchy”. Następnie w „Inspector” kliknąć przycisk „New Component”,
a w pole wyszukiwania wpisać „Rigidbody”. Po przesortowaniu przez Unity, dostępne są
dwie pozycje „Rigidbody” i „Rigidbody 2D”. W naszym wypadku, musimy użyć opcji
pierwszej. Gdy komponent został przypisany do naszego obiektu otwieramy zawinięte pole
„Contrains” i zaznaczamy cały rząd „Freeze Rotation”(aby uniknąć „wirowania” klocka przy
wciśnięciu kilku klawiszy na raz). Wykonanie czynności „zamrożenia rotacji” powoduje,
iż podczas dodawania siły w obliczeniach końcowych nie są brane pod uwagę zmienne
dotyczące rotacji.
Teraz przyszedł czas na najtrudniejsze. Czas stawić czoło największemu wyzwaniu –
programowaniu!
Temat 6. Programowanie ruchu i zbierania
Przygotowanie Przystępując do programowania, należy
przygotować nowy skrypt i połączyć go z obiektem,
który ma być przez niego obsługiwany. W tym celu
należy zaznaczyć nasz niebieski sześcian ponownie
kliknąć w New Component -> New Script -> Ustalić dla
niego nazwę: „Ruch” -> Upewnić się że wybranym
językiem jest C Sharp i zatwierdzić daną operację.
Po poprawnie wykonanym tworzeniu,
powinniśmy ujrzeć nowe pole: „Ruch (Script).
Dodatkowo skrypt powinien pojawić się w głównym
folderze Assets. Aby go otworzyć, wystarczy kliknąć na
niego dwukrotnie lewym przyciskiem myszy(LPM).
12
Wstęp do programowania
Każdy z nas powinien w tym momencie postawić przed sobą jedno, bardzo ważne
pytanie: „Czym jest tak naprawdę programowanie?”. Najprościej rzecz ujmując:
Programowanie to proces tworzenia i operowania danymi. Celem programisty jest stworzenie
programu który będzie wykonywał ściśle określone funkcje. Wiele osób myśli, że komputer
umie przewidywać, zgadywać, myśleć. Nic bardziej mylnego! Komputer nie wykona, żadnej
operacji, jeśli uprzednio programista nie wydał „rozkazu” jej wykonania.
W naszym przypadku mamy do czynienia z programowaniem obiektowym
w środowisku programistycznym do tego przystosowanym. Możemy korzystać z gotowych
obiektów, modyfikować je według własnych potrzeb oraz programować wykonywane przez
nie czynności.
Wyobraźcie sobie teraz obiekt którym będzie zwyczajne pudełko. Jak opisze to
programista?
Pierwszym kluczowym elementem będzie podanie rozmiarów tego obiektu:
Szerokość
Wysokość
Głębokość
Wyżej wymienione parametry w programowaniu określa się mianem zmiennych.
Nazwa wywodzi się stąd, iż na świecie mamy setki, a nawet tysiące pudełek, każde z nich
posiada różne rozmiary, więc możemy stwierdzić, że rozmiary pudełek są zmienne.
Następnie możemy wywnioskować dalsze zmienne jak:
Pojemność pudełka
Jego kolor
Aktualna objętość wody w pudełku
Maksymalna objętość wody w pudełku
Dodatkowo na pudełku można wykonywać określone czynności jak:
Wlewanie do niego wody
Wylewanie wody z pudełka
Te wyżej wymienione możliwe „operacje” na pudełku określa się jako metody. Będą
się one odwoływały do konkretnych parametrów jak na przykład „Aktualna objętość wody
w pudełku”.
Kolejnym ważnym aspektem będzie kontrolowanie stanu wody, którego poziom
będzie oddziaływał na możliwość wykonywania funkcji. Opisując to słownie:
1. Jeśli „Aktualna objętość wody” jest mniejsza od „Maksymalnej objętości wody
w pudełku” możesz dolać do niego kolejną porcje wody.
2. Jeśli „Aktualna objętość wody” jest równa „Maksymalnej objętości wody w pudełku”
odlej z niego połowę.
Tego typu określenia nazywa się w programowaniu instrukcjami warunkowymi.
13
Zmienne
Kluczowym elementem zrozumienia programowania jest poznanie zasad tworzenia
i posługiwania się zmiennymi. Są one tworzone w ściśle określony sposób i podlegają kilku
ważnym regułom.
Jak tworzymy zmienne?
Po pierwsze każda zmienna musi posiadać określony typ. Oznacza to, iż z góry
musimy wiedzieć do jakiego formatu liczb będzie nam potrzebna. W języku c# wyróżniamy
8 podstawowych typów zmiennych:
short – liczba całkowita z zakresu -215 do 215-1
int – liczba całkowita z zakresu -231 do 231-1
long – liczba całkowita z zakresu -263 do 263-1
float – liczba zmiennoprzecinkowa z zakresu około -1,5*10-45 do 3,4*1038
double – liczba zmiennoprzecinkowa z zakresu około -5,0*10-324 do 1,7*10308
char – pojedynczy znak Unicode.
string – ciąg znaków Unicode.
bool – wartośd logiczna prawda/fałsz; za zakres przyjmuje parametr true lub false.
Następnie po określeniu typu zmiennej musimy zadeklarować jej nazwę. Warto
zaznaczyć, że język c# rozpoznaje wielkość liter w nazwach zmiennych, „liczba” a „Liczba”
to dwie różne zmienne!
Zasady nazewnictwa zmiennych
1. Nazwa zmiennej nie może zawierać w nazwie spacji, słów kluczowych jak „int”,
„float”, „new”, „if”, itp.
2. Nazwa zmiennej może zawierać tylko litery alfabetu łacińskiego, cyfry oraz znak „_”;
nie wolno stosować „ą”, „ę”, „ó”, „ł” itp.
3. Nazwa zmiennej powinna rozpoczynać się literą lub podkreśleniem.
4. Nazwa nie może rozpoczynać się od cyfry.
5. Nazwa powinna jasno opisywać daną zmienną, np. zmienna przechowująca adres dane
ilości jabłek znajdujących się w skrzynce powinna mieć nazwę
ilosc_jablek_w_skrzynce.
6. Po jej zdefiniowaniu należy postawić „;”(średnik).
Przykładowe zmienne
int przykladowa_zmienna;
float sekundy_do_konca;
14
Podstawowe operacje wykonywane na zmiennych
Podstawowe operacje jakie można wykonywad na zmiennych:przypisanie wartości poprzez
znak „=”, czyli int przykladowa_zmienna = 100;
spowoduje to iż przykladowa_zmienna przechowuje teraz wartośd sto;int
ilosc_jablek_w_skrzynce = 500;
przykladowa_zmienna = ilosc_jablek_w_skrzynce; Teraz zmienna przykladowa_zmienna przechowuje wartośd 500.
dodawanie poprzez znak „+”, czyli
przykladowa_zmienna = przykladowa_zmienna + 20; jeśli przyjmiemy zatem, iż na początku przykladowa_zmienna miała wartośd 100, teraz po
wykonaniu tej czynności jej wartośd to 120.
odejmowanie poprzez znak „-”, czyli
przykladowa_zmienna = przykladowa_zmienna - 40; przyjmując zatem, iż na początku przykladowa_zmienna miała wartośd 100, po odjęciu 40,
ma wartośd 60.
mnożenie poprzez znak „*”, czyli
przykladowa_zmienna = przykladowa_zmienna * 2; na początku przykladowa_zmienna miała wartośd 100, po pomnożeniu ją przez 2, ma wartośd
200.
dzielenie, tym razem poprzez znak „/”, czyli
przykladowa_zmienna = przykladowa_zmienna / 4; przykladowa_zmienna miała wartośd 100, po podzieleniu ją przez 4, ma wartośd 25.
Funkcje Funkcje są zbiorem operacji które maja zostać wykonane w ściśle zdefiniowany przez
ich autora sposób. Mogą one wykonywać operacje na zmiennych bądź same być pewną
częścią innej, bardziej złożonej funkcji. Każda funkcja musi mieć określony typ zwracanej
wartości. Jeśli funkcja nie zwraca wartości określamy jej typ jako „void”.My na potrzeby tego
kursu zajmiemy się tylko i wyłącznie typem „void”.
Budowa funkcjiTyp zwracanej wartości(short, int, long, float, double, char, string,
bool, void)
Nazwa funkcji: Obowiązują identyczne zasady jak przy nazewnictwie zmiennych.
Dodatkowo jednak po nazwie musi występować „()” jeśli funkcja nie otrzymuje
żadnych parametrów lub (lista parametrów) jeśli funkcja otrzymuje parametry(typ
i liczba parametrów jest dowolna).
Przykładowa deklaracja funkcji
void wyswietl_przykladowa_zmienna();
Po zadeklarowaniu funkcji należy zdefiniować ją, czyli określić co ma robić używając
do tego nawiasów klamrowych, będących granicą ciała funkcji. Pod deklaracją piszemy
ponownie typ, nazwę funkcji nawiasy lecz tym razem zamiast średnika stosujemy nawiasy
klamrowe a w ich wnętrzu zapisujemy treść naszej funkcji.
15
void wyswietl_przykladowa_zmienna() {
printf(przykladowa_zmienna);
}
Nasza funkcja będzie odpowiedzialna za wyświetlenie „przykladowej_zmiennej”.
printf(parametr); - to funkcja wbudowana w środowisko Unity. Odpowiada ona za
wyświetlenie wartości podanego parametru w polu „Console”, które w trybie uruchomienia
programu pojawia się w miejscu pola „Project”.
Programowanie ruchu w Unity Domyślnie, tuż po otwarciu naszego skryptu o nazwie „Ruch.cs” powinniśmy ujrzeć:
using UnityEngine; using System.Collections; public class Ruch : MonoBehaviour { // Use this for initialization void Start () { } // Update is called once per frame void Update () { } }
Pomijamy tłumaczenie pierwszych czterech linijek. Są one tworzone domyślnie przez
Unity i nie mają tak ogromnego znaczenia dla potrzeb tego kursu.
Na pierwszy rzut oka dostrzegamy dwie funkcje z komentarzami zapisanymi
za pomocą „//”, czyli objaśnień, które są pomijane w procesie kompilacji. Omówmy je:
Funkcja Start() jak możemy wywnioskować z jej komentarza służy do inicjowania.
Jest ona wywoływana jednokrotnie, automatycznie podczas uruchomienia programu. Należy
w niej zawrzeć wszystkie polecenia, które będą niezbędne do dalszego działania programu,
np. inicjacja zmiennych czy przypisywanie do zmiennych innych parametrów jak
np. pobranie daty/godziny itp.
Funkcja Update() jest wywoływana cyklicznie co każdą klatkę. Możemy w prosty
sposób wyliczyć, że jeśli nasz program będzie pracował w trybie 60 klatek na sekundę,
oznacza to, iż funkcja ta będzie wykonana 60 razy w ciągu sekundy! Jak sama nazwa
wskazuje funkcji tej używa się do aktualizowania danych. To właśnie w niej zawrzemy
wszystkie polecenia niezbędne do wykonania operacji ruchu.
Uzupełnianie skryptu
void Update () { float translationZ = Input.GetAxis("Vertical") * 18; float translationX = Input.GetAxis("Horizontal") * 18; GetComponent<Rigidbody>().AddForce(translationX, 0, translationZ);
}
16
Uzupełniamy naszą funkcję Update() o trzy wyżej wymienione linijki. Dwie pierwsze
odpowiadają za przypisanie do dwóch utworzonych lokalnie zmiennych wartości zwróconych
przez metodę(funkcję) z klasy Input odpowiadającej za obsługę wejścia.
Jako parametr do funkcji GetAxis podajemy ciąg znaków „Vertical” – odpowiadający
za ruch w pionie i „Horizontal” – odpowiadający za ruch względem poziomu. Pobrane
wartości są tak małe, że nie nadałaby odpowiedniej siły dla obiektu w Unity o masie równej 1
(Parametry w komponencie Rigidbody). Aby nie zmieniać masy obiektu w prostu sposób
pomnożymy zwracane parametry, przez co uzyskamy wyższe wartości.
Następnie przystępujemy do dodania tych sił do naszego obiektu. Tworzymy to za
pomocą metody należącej do komponentu Rigidbody. Aby odwołać się do komponentu
przypisanego do tego samego obiektu co aktualny skrypt wystarczy użyć
GetComponent<nazwa_komponentu>() w naszym wypadku jest to Rigidbody. Gdy chcemy
odwołać się do jakiejś metody zawartej w tym komponencie identycznie jak
w programowaniu obiektowym odwołujemy się do niej za pomocą operatora kropki.
Następnie wpisujemy nazwę funkcji, w naszym wypadku AddForce(czyli dodanie siły)
i podajemy do niej parametry, odpowiadające za przekształcenia względem osi X( czyli
pierwszy parametr), względem osi Y pozostawiamy zero, ponieważ nie zmieniamy pozycji
obiektu względem pionu i ostatni parametr odpowiadający za przekształcenia na osi Z.
Testy
Teraz przechodzimy do Unity i klikamy przycisk „Play”, aby uruchomić nasz
program. Jeżeli możemy poruszać naszym sześcianem za pomocą strzałek, oznacza to, że
wszystko wykonaliśmy poprawnie. Jeśli program nie działa poprawnie, należy wrócić
do kodu i sprawdzić wszystko krok po kroku czy kod został poprawnie uzupełniony.
Zbieranie punktów W tym podrozdziale zajmiemy się wyświetlaniem tekstu na ekranie gry, zliczaniem
punktów oraz systemem zbierania klocków, które po kolizji mają zostać usunięte z ekranu.
Tekst na ekranie
Aby móc wyświetlać tekst na ekranie gry należy utworzyć nowy obiekt tekstowy
należący do UI.
Tworzenie tekstu wymaga utworzenia obiektu i umieszczenia go wedle uznania na
ekranie. Aby utworzyć nowy obiekt tekstowy należy:
Przejść do pola Hierarchy
Kliknąć prawym przyciskiem myszy w puste pole wybrać menu UI->Text
Możemy zauważyć iż zostały utworzone 3 obiekty:Canvas, Event System i Text.
Canvas jest obszarem, w którym powinny znajdować się wszystkie elementy UI.
Event System odpowiada za odczytywanie wejścia (jak np. mysz) sprawdzającczy
kliknęliśmyna dany guzik.
Text jest naszym obiektem tekstowym.
Ustawienia tekstu
W polu Hierarchy klikamy dwukrotnie na Canvas. Teraz w polu Scene powinniśmy
widzieć zbliżony obraz.
17
Zaznaczamy obiekt Text i za pomocą strzałek przesuwamy obiekt ku górze.
Dodatkowo aby tekst był lepiej widoczny podczas gry w polu Inspector zmieniamy parametr
Font Size z 14 do 24.
Możemy już powrócić do obiektu gracza, klikając dwukrotnie na jego nazwę
w zakładce Hierarchy.
Tworzenie skryptu „Zbieranie”
Po przejściu do gracza w polu Inspector klikamy Add Component i wybieramy New
Script, nadajemy mu nazwę „Zbieranie” oraz upewniamy się, że wybrany jest język C#.
Teraz do naszego kodu, który powinien wyglądać następująco:
using UnityEngine; using System.Collections; public class Zbieranie : MonoBehaviour { // Use this for initialization void Start () { } // Update is called once per frame void Update () { } }
Po using System.Collections; dodajemy using UnityEngine.UI; który będzie
odpowiadał za załadowanie niezbędnych do pracy elementów.
Następnie przejdziemy do utworzenia dwóch zmiennych, pierwszej która będzie
reprezentantem naszego tekstu i drugą, która będzie przechowywała aktualną liczbę
zebranych punktów, więc w naszym kodzie w wierszu następnym za otwierającym nawiasem
klamrowym powinny znaleźć się dwie nowe linie:
int aktualnaLiczbaPunktow = 0; Text text_uGory_Punkty;
18
Teraz musimy zainicjalizować naszą zmienną tekstową i przypisać do niej obiekt.
Zrobimy to w funkcji Start() za pomocą następującej frazy:
using UnityEngine; using System.Collections; public class Zbieranie : MonoBehaviour {
int aktualnaLiczbaPunktow = 0; Text text_uGory_Punkty;
// Use this for initialization void Start () { text_uGory_Punkty = GameObject.Find("Text").GetComponent<Text>(); } // Update is called once per frame void Update () { } }
Przystąpmy do omówienia. Przypisywanie wygląda identycznie jak przy każdej
zmiennej, po lewej stronie zmienna, której nadajemy wartość, po prawej to co chcemy
przypisać. Teraz naszym zadaniem jest odnalezienie tego obiektu w naszej grze. Robimy to za
pomocą: GameObject.Find(„nazwaObiektuUmieszczonaWCudzysłowie”)
Następnie za pomocą operatora kropki, odwołujemy się do komponentu Text.
Teraz musimy pamiętać, aby na bieżąco uaktualniać nasz licznik. Wykonamy to
w funkcji Update() za pomocą:
text_uGory_Punkty.text = "Punkty: " + aktualnaLiczbaPunktow.ToString();
Przypisanie danej wartości do naszego licznika wygląda następująco. Z naszej
zmiennej text_uGory_Punkty odwołujemy się do zmiennej text, która to odpowiada za
przechowywanie wartości tekstowej następnie po operatorze przypisania wpisujemy
„Punkty:” a następnie za pomocą operatora + „dołączamy” nazwę zmiennej, której wartość
chcemy przypisać. Konwertujemy ją do zmiennej tekstowej za pomocą operatora ‘.’
i ToString(). Ostatnim fragmentem naszego kodu będzie funkcja wbudowana w środowisko
Unity o nazwie OnTriggerEnter(). Będzie ona sprawdzała czy obiekt gracza nie wchodzi
w kolizję z innym obiektem. Znajdzie ona zastosowanie w zbieraniu punktów.
void OnTriggerEnter(Collider col) { if(col.gameObject.transform.tag == "Punkt") { aktualnaLiczbaPunktow++; Destroy(col.gameObject); } }
Parametr Collider jest pobierany automatycznie. We wnętrzu funkcji znajduje się
instrukcja warunkowa sprawdzająca poprzez operator „==” czy obiekt z którym nasz gracz
19
koliduje posiada tag odpowiadający nazwie „Punkt”. Tagi są obok nazwy kolejnym
identyfikatorem obiektu na scenie.
Po omówieniu funkcji wrócimy do Unity. Utworzymy nasze punkty, będące małymi
żółtymi sześcianami i przypiszemy im odpowiedni tag. Jeśli warunek zostanie spełniony,
czyli obiekt z którym wejdziemy w kolizje będzie miał tag „Punkt” należy podnieść aktualną
liczbę punktów o jeden poprzez: aktualnaLiczbaPunktow++; a następnie zniszczyć punkt:
Destroy(col.gameObject);
Edycja skryptów zakończona. Poniżej znajdują się dwa pełne skrypty. Jeśli wszystko
się zgadza, możemy przejść do kolejnego kroku.
Ruch.cs:
using UnityEngine; using System.Collections; public class Ruch : MonoBehaviour { // Use this for initialization void Start () { } // Update is called once per frame void Update () { float translationZ = Input.GetAxis("Vertical") * 18; float translationX = Input.GetAxis("Horizontal") * 18; GetComponent<Rigidbody>().AddForce(translationX, 0, translationZ); } }
Zbieranie.cs:
using UnityEngine; using System.Collections; using UnityEngine.UI; public class Zbieranie : MonoBehaviour { int aktualnaLiczbaPunktow = 0; Text text_uGory_Punkty; // Use this for initialization void Start() { text_uGory_Punkty = GameObject.Find("Text").GetComponent<Text>(); }
20
// Update is called once per frame void Update() { text_uGory_Punkty.text = "Punkty: " + aktualnaLiczbaPunktow.ToString(); } void OnTriggerEnter(Collider col) { if(col.gameObject.transform.tag == "Punkt") { aktualnaLiczbaPunktow++; Destroy(col.gameObject); } } }
Temat 7. Tworzenie punktów
Tworzenie punktu Stosując się do naszej historii gry, musimy
utworzyć żółty sześcian, który następnie
pomniejszymy, nadamy mu tag i utworzymy z niego
prefab, czyli wzorzec według którego będą
powstawały identyczne kopie naszego obiektu.
Analogicznie jak w przypadku tworzenia
obiektu gracza, tworzymy sześcian i nadajemy mu
żółty kolor oraz dołączamy komponent Rigidbody.
Następnie udajemy się do panelu Inspector i skalujemy
go względem wszystkich osi do rozmiaru: 0.5.
W polu Inspektor klikamy w pole tag i na
rozwijanym menu wybieramy opcję add Tag. Po
otwarciu nowego panelu klikamy symbol „+” i
wpisujemy: „Punkt”. Teraz po powrocie do Inspectora
ponownie klikamy na listę i tym razem wybieramy
świeżo utworzony tag – Punkt. Dodatkowo, aby łatwiej
było nam identyfikować obiekt zmieńmy również jego
nazwę na Point.
Gdy wszystko wykonaliśmy poprawnie w polu
Project tworzymy nowy folder o nazwie refabs i z pola
Hierarchy przeciągamy Point do naszego folderu. W
ten oto sposób został utworzony prefab - wzorzec
naszego punktu. Aby dodać więcej punktów na scenę
nie musimy się już trudzić ponownym ustalaniem tych
obiektów, wystarczy, że przeciągniemy nasz prefab z
folderu na scenę i utworzymy identyczną kopię naszego wzorca. Należy pamiętać, że
jakakolwiek zmiana wprowadzona w prefab skutkuje zmianą we wszystkich jego kopiach!
21
Teraz klikamy przycisk „Play” i cieszymy się z naszej nowej gry!!!
22
Mam nadzieję, że mój przewodnik spełnił Twoje oczekiwania i pozwolił Ci stworzyć
pierwszą, własną grę. Programowanie tak na prawdę nie jest trudne, sedno tkwi w tym, jak
bardzo chcesz coś zrobić i ile z siebie dasz, tak jak powiedział mój mentor Marszałek Józef
Piłsudski:
"Być zwyciężonym i nie ulec to zwycięstwo, zwyciężyć i spocząć na laurach to klęska.
Kto chce, ten może, kto chce, ten zwycięża, byle chcenie nie było kaprysem lub bez
mocy.".
Chciałbym bardzo podziękować Pani Profesor Annie Tracz za pomysł i pomoc
w realizacji tego przedsięwzięcia. Pani Profesor, dziękuję za poświęcony czas, wiedzę i dobre
słowa!
Jakub Klementewicz