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