Crearea Unui Joc 2d Folosind Unity

CUPRINS

Introducere…………………………………………………………………………..3

CAPITOLUL I Ce anume este Unity și la ce îl putem folosi………………….4

I.1. Puțină prezentare………………………………………………………………………………4

I.2. La ce e folosit Unity și cine îl poate folosi…………………………………………….5

CAPITOLUL II Conceptul jocului creat …………………………………………………… 7

II.1. Scena Start………………………………………………………………………………………7

II.2. Scena Meniu…………………………………………………………………………………….8

II.3. Scena Dificultate………………………………………………………………………………8

II.4. Scena Nivel……………………………………………………………………………………..9

II.5. Scena Final…………………………………………………………………………………….10

CAPITOLUL III Cum dezvoltăm de la zero un joc 2D în Unity………………..11

III.1. Crearea unui proiect nou și prezentarea interfeței…………………………….11

III.2. Asset-uri……………………………………………………………………………………….13

III.3. Realizarea scenelor………………………………………………………………………20

Concluzii ……………………………………………………………………………………………………..38

Bibliografie…………………………………………………………………………………………………..40

INTRODUCERE

Luând în considerare faptul că marea majoritate a populației își consumă o mare parte din timp jucându-se pe calculator/tabletă/telefon/consolă am considerat de cuviință să realizăm, în lucrarea de față, un joc. Iar ca să nu ne certe profesorii că pierdem vremea cu jocurile, am hotarât să realizăm un joc educativ care să îmbine utilul cu plăcutul: învățăm bazele de numerotație binar, hexa și octa, țintind baloane.

Am ales să folosim Unity ca platformă de dezvoltare a jocului, deoarece în primul rând poate fi folosită gratuit și nu în ultimul rând, pentru că este foarte populară în domeniul dezvoltării jocurilor. Deși Unity este un Game Engine făcut în special pentru jocurile 3D și mai puțin pentru cele 2D, am considerat totuși că vom aborda simplitatea jocurilor 2D.

Deși în mare parte se vor folosi termeni de specialitate, vom încerca pe cât posibil o abordare bazată pe partea practică astfel încât imaginile să îndrume și pe cei mai puțin familiarizați cu noțiunile din domeniul informaticii.

Lucrarea poate constitui un suport practic și, în parte, teoretic pentru crearea unui joc folosind Unity. Este menită să ofere concepte relevante privind programarea în Unity, în contextul dezvoltării jocurilor 2D.

Primul capitol „Ce anume este Unity și la ce îl putem folosi” va prezenta, în mare, platforma utilizată pentru dezvoltarea aplicației și răspunde la unele întrebări de genul: ce este Unity, care sunt posibilitățile de a ni-l procura, cine îl poate folosi, la ce îl folosim etc.

Al doilea capitol “Conceptul jocului creat ” prezintă modul în care a fost gândit jocul, dezvoltat pe scene. Fiecare scenă este explicată în detaliu, acest capitol fiind un manual de utilizare și prezentare a aplicației.

Al treilea capitol “Cum dezvoltăm de la 0 un joc 2D în Unity” aprofundează dezvoltarea aplicației; se trece treptat de la crearea unui nou proiect, la prezentarea uneltelor folosite(asset-urilor) și în final la crearea scenelor în detaliu cu prezentarea codului (scripting-ului) care face legătura între acestea.

Notă: Aplicația din această lucrare a fost realizată sub Unity 5, disponibil pe site-ul producătorului la adresa https://unity3d.com/get-unity în versiunea gratuită, Personal.

CAPITOLUL I

Ce anume este Unity și la ce îl putem folosi

I.1.Puțină prezentare

Unity este o platformă de game engine, creată de Unity Technologies și folosită pentru dezvoltarea de jocuri video pentru calculatoare, mobile, console și website-uri. Deși în 2005, când a apărut pe piață, a fost anunțat ca fiind doar pentru Mac OS, în prezent este folosit pe mai bine de 15 platforme printre care BlackBerry , Windows Phone 8, Windows, OSX, Android, Adobe Flash, PlayStation Vita, Xbox One, Wii.* Numele pe care-l poartă, și anume de cross-platform, îi vine de la faptul că jocurile pot fi ușor și repede portate pe Android, iOS, BlackBerry etc. Folosind Unity s-au realizat jocuri renumite precum Tetris, Super Mario Brothers, Angry Birds, Minesweeper, Civilization, Bejewelled și multe altele.

În top 3 cele mai folosite game engine, pe lângă Unity mai sunt Unreal Engine și CryEngine. Unreal Engine este succesorul UDK și are capabilități grafice excepționale ca lumina dinamică, iar ca limbaje de programare folosite, UnrealScript și C++.

CryENGINE este destinat folosirii pe PC și console, iar prin capabilitățile acestuia din urmă le surclasează pe celălalte două prin animații avansate și fizică realistă. Dintre cele trei, CryENGINE este și cel mai pretențios în ceea ce privește cunoștințele în domeniu ale celui care îl folosește.

Game Engine-ul Unity poate fi download-at de pe site-ul producătorilor https://unity3d.com/get-unity/download fiind disponibil atât în versiunea gratuită, cea Personal, cât și în versiunea ce poate fi cumpărată, cea Professional. Chiar dacă versiunea Professional prezintă mult mai multe avantaje, considerăm că cea Personal poate fi utilizată fără probleme chiar și pentru jocuri mai complicate. Varianta gratuită oferă posibilitatea de a experimenta, învăța și de a crea jocuri.

I.2. La ce e folosit Unity și cine îl poate folosi

Unity suportă realizarea atât a jocurilor 3D cât și a celor 2D, ceea ce e puțin neobișnuit pentru un game engine. Deși realizat în scopul creării de jocuri 3D, ulterior a început să ofere suport și pentru jocurile 2D.

Caracteristicile 2D erau la început doar pentru realizarea meniului și ecranelor 2D necesare în jocurile 3D, pentru a evita necesitatea unor unelte externe. Caracteristicile erau generice și programatorii au început să creeze jocuri cu ele. Chiar dacă nu are decât niște forme primitive ca și caracteristici de modelat și construit, totuși oferă o vastă bibliotecă de asset-uri care pot fi download-ate sau cumpărate.

Modelul 3D se referă la reprezentarea matematică a unui obiect tri-dimensional(având toate cele 3 axe (Ox, (Oy și (Oz.) folosite în spațiu. Modelul de jocuri 2D se se bazează în principal pe cele 2 coordonate principale în plan X și Y. Diferența esențială între cele 2 este că graficele 2D se măsoară și se dimensionează în pixeli pe când cele 3D în unități de măsură reali, adesea metri.

În jocurile 2D jucătorii, în mod normal, nu pot roti sau muta camera în spațiul 3D așa încât să vadă obiectele din alte unghiuri sau perspective. Obiectele în sine se pot mișca doar în două dimensiuni, de-a lungul axelor (Ox si (Oy , adică stânga/dreapta pe (Ox și sus/jos pe (Oy, dar nu și de-a lungul axei (Oz, adică înainte/înapoi. Trebuie menționat că există însă și excepții de la regulă, dar în principal 2D înlătură cea de-a treia dimensiune, principală într-un joc.

Sunt folosite, în Unity, trei limbaje de programare: C#, UnityScript(asemănător cu JavaScript) și Boo. Ultimul din acestea, Boo, nu este prea folosit și e de evitat. Cel mai folosit limbaj de programare în acest caz este C#. Dacă aveți un joc simplu de făcut și aveți cunoștințe de JavaScript, puteți alege însă UnityScript, dar dacă veți avea nevoie de plugin-uri va trebui să apelați totuși la C#.

Ca și utilizare, Unity nu se adresează doar programatorilor profesioniști. Acesta poate fi utilizat de oricine, însă e de preferat să aibă cunoștințe de programare, în special de C# pentru a putea realiza comportamentul jocului. Prin urmare, fie că este vorba despre un student la informatică, sau un programator independent, sau un inițiat în game development, sau un experimentat în game development care urăște scrierea de cod, acest game engine este pentru fiecare.

Realizarea jocurilor poate fi o adevărată provocare, în mare parte datorită faptului că sunt necesare cunoștințe în domeniul programării. Unity folosește pentru implementarea open source MonoGame Framework. Acest framework oferă posibilitatea programatorilor de a învăța rapid informațiile necesare începerii creării unui joc 2D pentru multe din platformele renumite.

MonoGame framework își prezintă interfața în limbajul de programare C#. Utilizând C# ne putem folosi de abstractizare și moștenire în modelarea comportamentelor elementelor jocului, evitând astfel să ne preocupăm de manipularea pointerilor sau de managementul memoriei. Privind astfel situația ne putem da seama că, folosind MonoGame și C# care este disponibil gratuit, putem realiza jocuri gratuit pentru mai multe platforme.

CAPITOLUL II

Conceptul jocului creat

Jocul în sine presupune pe scurt alegerea bazei de numerotație dorite(2, 8 sau 16) și a nivelului dorit(începător, mediu sau avansat) și în final jocul propriu-zis care constă în afișarea unor numere în baza aleasă și în țintirea cu arcul a baloanelor cu numărul corespondent în baza 10, astfel încât să se cumuleze cât mai multe puncte.

Jocul este creat folosind 5 scene: Start, Meniu, Dificultate, Nivel și Final.

II.1 Scena Start (fig.II.1)

Fiind prima scenă aici începe jocul, prin urmare are un buton de Play pentru intrarea în joc, care face trecerea la Scena Meniu și un buton de Exit pentru ieșirea definitivă din joc.

Fig.II.1 Scena Start

Sursa background: http://static2.wallpedes.com/wallpaper/wallpapers/wallpapers-for-gt-computer-science-background-hd-computer-wallpapers-hd-wallpaper-free-download-desktop-full-size-images-background-3d.jpg

II.2 Scena Meniu (fig.II.2)

Din această scenă se poate face trecerea fie la scena anterioară(Scena Start) prin butonul de înapoi, fie la scena următoare(Scena Dificultate) prin alegerea unuia din cele trei butoane 2, 8 și 16, în funcție de dorința jucătorului privitoare la baza de numerotație în care se va juca. Și această scenă are un buton de Exit pentru ieșirea definitivă din joc.

Fig.II.2 Scena Meniu

Sursa background: http://milliwall.com/wp-content/uploads/2015/03/Tumblr-Background-Vintage-41-Wallpaper-HD.jpg

II.3 Scena Dificultate (fig.II.3)

În această scenă jucătorul poate alege să revină la scena anterioară(Scena Meniu) sau să continue alegând unul dintre cele 3 dificultăți de joc: începător, mediu și avansat. Diferența de dificultate constă în faptul că de la un nivel la altul crește viteza baloanelor și totodată numărul dat, pentru a fi țintit corespondentul său în baza aleasă, este ales dintr-un interval mai îndepărtat de 0 astfel încât să fie mai greu de găsit.

Fig.II.3 Scena Dificultate

Sursa background: https://encrypted-tbn0. gstatic.com/images?q=tbn: ANd9GcTzjw1rz

8K1RK8B6zGh5oFYxu1DyyzL0xM4EvdrPAFNL_2Ub55F

II.4 Scena Nivel (fig.II.4)

În această scenă jucătorul ia parte la joc țintind cu săgeata balonul, care îl consideră el că e corespondentul numărului dat de joc, la întâmplare, în baza aleasă anterior de jucător în Scena Meniu. La o realizare a jocului cap-coadă, jucătorului i se oferă 10 numere în baza aleasă cărora jucătorul trebuie să le găsească corespondentul într-unul dintre baloane și să țintească balonul respectiv. Pentru țintirea balonului corespondent corect, jucătorul obține 10 puncte, astfel încât, dacă la final țintește toate baloanele corecte va acumula 100 puncte. După terminarea jocului se va trece direct la scena următoare(Scena Final). Jucătorul are oricând posibilitatea de a ieși complet din joc, dacă acesta dorește, prin apăsarea butonului de Exit.

Sursa imagine background: http://nationalalarm.us/?attachment_id=470

Sursa balon :http://www.maplecityrubber.com/wpcontent/themes/maple_city/images/

balloon_gold. png

Fig.II.4 Scena Nivel

II.5 Scena Final (fig.II.5)

Această scenă fiind ultima va afișa scorul final obținut de jucător și oferă jucătorului posibilitatea, fie de a ieși definitiv din joc folosind butonul de Exit, fie să revină la Scena Meniu, dacă mai dorește să joace din nou, și să-și aleagă din nou jocul.

Fig. II.5 Scena Final

Sursa background: http://static2.wallpedes.com/wallpaper/wallpapers/wallpapers-for-gt-computer-science-background-hd-computer-wallpapers-hd-wallpaper-free-download-desktop-full-size-images-background-3d.jpg

CAPITOLUL III

Cum dezvoltăm de la zero

un joc 2D în Unity

Ca și concept high-level, Unity presupune proiecte, asset-uri și scene. Un joc reprezintă un proiect integral; asset-urile reprezintă fișierele jocului; scenele pot fi privite ca secțiuni ce includ obiectele jocului.

În acest capitol vom prezenta crearea unui nou proiect, ce anume sunt asset-urile și cum le folosim în proiect și în final vom arăta cum am realizat scenele jocului și prezenta totodată și codul(scriptingul C#) ce reprezintă comportamentul jocului.

III.1) Crearea unui proiect nou și prezentarea interfeței

În Unity realizarea unui joc înseamnă de fapt realizarea unui proiect, acesta din urmă reprezentând un container pentru fișierele și datele jocului.

Crearea unui nou proiect

Fig.III.1 Căsuța de dialog pentru crearea unui nou proiect

Pentru a crea un nou proiect trebuie să dăm click pe File > New Project sau folosind combinația de taste Ctrl + N. În căsuța de dialog deschisă(fig. III.1) putem alege numele proiectului, locația unde se va salva proiectul și felul(2D sau 3D, în cazul nostru 2D).

Pentru a deschide un proiect deja existent vom da click pe File > Open Project.

Interfața Unity

Odată creat un nou proiect, Unity va afișa interfața implicită(fig.III.2), urmând ca aici să se desfășoare mare parte din creația jocului, prin urmare o vom putea numi masa de lucru. Masa

noastră de lucru este formată din cinci zone iar pe unele le vom prezenta pe scurt în cele ce urmează:

Meniul;

Hierarchy;

Project Panel;

Inspectorul;

Viewport Area.

Fig.III.2 Interfața Unity: 1)Meniu; 2)Hierarchy; 3)Project Panel; 4) Inspectorul; 5) Viewport Area

Hierarchy listează, după nume, fiecare obiect creat(lumini, camere, creaturi, ș.a.m.d.), chiar dacă nu sunt vizibile pentru jucător. Pentru a selecta și a vedea mai bine un obiect trebuie să facem dublu click pe el.

Project Panel arată conținutul dosarului proiectului situat pe hard drive. În această zonă este expus dosarul Asset-urilor, aici fiind stocate fișierele jocului. De fiecare dată când facem update la fișierele asset, modificările se văd imediat în joc. Ștergerea respectiv copierea datelor cuprinse aici trebuie făcută cu mare grijă pentru a nu a afecta integritatea jocului.

Inspectorul prezintă proprietățile obiectelor jocului, acestea putând fi vizualizate și editate ca urmare a selectării obiectului jocului dorit, atât la timpul design-ului cât și la rulare.

Viewport Area presupune 2 secțiuni(tabs): Scene și Game. Acestea pot fi privite ca două ferestre care se pot pune una peste alta facându-se interschimbarea prin click pe tab-ul cu numele dorit, sau se pot pune ambele în fereastra Viewport Area realizând drag&drop cu una dintre ele(fig.III.3), în cazul în care dorim să le vedem în paralel. Secțiunea Scene e folosită de programator pentru a transforma scenele în lumi credibile. Secțiunea Game arată scena din perspectiva jucătorului.

Fig.III.3 Viewport Area cu Scene tab și Game tab expuse în paralel

III.2) Asset-uri

Fiecare fișier este un asset particular. Doar asset-urile din Project Panel pot fi folosite în prezentul joc. Ele pot fi importate în Unity selectând din meniu Assets > Import New Asset… (fig.III.4) , ca fișier separat sau ca fișiere multiple, fiindu-le atribuite automat settinguri și proprietăți care se pot vedea și totodată modifica din Inspector. Asset Store oferă gratuit sau contra cost asset-uri în cazul în care dorim să importăm asset-uri gata realizate.

E indicat să punem etichete la asset-uri când lucrăm cu proiecte mari sau când vrem să păstrăm organizate asset-urile. Astfel le vom putea căuta mai ușor după etichetă în secțiunea search din Project View. Când realizăm back-up pentru un proiect întotdeauna trebuie să facem back-up la dosarele Assets, ProjectSettings și la Library. Dosarul Library conține toată meta data și toate conexiunile între obiecte, astfel încât dacă acesta se pierde se pierd și legăturile între scene și asset-uri.

Fig.III.4 Importarea Asset-urilor

Asset-urile pot fi meshes, materiale, texturi, shaders(forme), fișiere video, fișiere video, animații, text și multe altele, Unity acceptând o varietate largă de formate de fișiere.

Meshes

Acestea sunt modele 3D și pot fi reprezentate prin orice lucru tangibil din scenă(inamic, jucător, pereți, ș.a.m.d.). Sunt alcătuite din animație, mapping și geometrie(vârfuri, laturi, fațete, etc.). Toate cele trei componente crează un obiect și ne dau date despre suprafața acestuia. Meshes-urile sunt de fapt suprafațe rectangulare în patru colțuri realizate fiecare din 2 triunghiuri dreptunghice lipite prin ipotenuze. Aceste suprafețe se comportă ca o bucată de hârtie care aliniată cu camera poate arăta imagini și texturi.

Obiectele statice din joc trebuiesc bifate la proprietatea Static în Object Inspector pentru optimizare și îmbunătățirea performanței.

Materiale, texturi și shaders(forme)

Asset-urile legate de grafica jocului se rezumă la texturi, shaders și materiale. Vom expune pe fiecare din cele trei în cele ce urmează, dar fig. III.5 de mai jos surprinde cel mai bine legătura dintre ele. Este de luat în calcul faptul că texturile nu se aplică direct modelelor(obiectelor). În schimb, texturile și shaders sunt aplicate materialelor și în final materialele se aplică modelelor dorite. Toată grafica jocului, de la caractere la background și efecte, sunt implementate sub forma materialelor și texturilor.

.

Fig.III.5 Relația între texturi, shader și materiale

Sursa: http://www.informit.com/articles/article.aspx?p=2162089&seqNum=2

Materialul este o formulă ce definește cum ar trebui să arate suprafața obiectului. În mare, materialele sunt containere pentru shaders și texturi ce pot fi aplicate obiectelor. Pentru a crea un material nou vom începe prin a crea un dosar Materials în Assets Panel (click dreapta > Create > Folder). Apoi pentru a crea un nou material tot în Assets Panel click dreapta > Create > Material (ca în fig.III.6).

Fig.III.6 Crearea unui material nou

Texturile sunt imaginile aplicate obiectelor. Acestora li se datorează faptul că obiectele sunt interesante și colorate în loc să fie plictisitoare și obișnuite. Deși ar părea ciudat faptul că o imagine 2D poate fi aplicată unui obiect 3D, în realitate se întâmplă. Dacă am lua imaginii eticheta ne-am da seama că nu e nimic altceva decât o bucată de hârtie. Acea etichetă este ca o textură care îi oferă un aspect mai plăcut.

Un material poate avea una sau mai multe texturi. Texturile sunt de fapt imagini (fișiere BMP, JPEG sau PNG) pixelate care dau culoare suprafeței obiectului. Importarea texturilor se face fie la pachet(selectând Assets > Import Package) fie individual cu drag&drop de pe calculator din Windows Explorer.

O textură se aplică unui material folosind drag&drop cu imaginea dorită la proprietățile materialului din Asset Panel în Inspector ca și în fig.III.7. Rezultatul se va vedea în partea de jos a Inspectorului.

Fig.III.7 Aplicarea unei texturi la material folosind drag&drop

Pentru a nu întâmpina probleme cu importarea, respectiv utilizarea texturilor importate aceste imagini trebuie să respecte pe cât se poate 2 reguli de bază:

Dimensiunea imaginii să fie 2n (putere a lui 2: 4, 8, 16, 32, 64, 128, 256, 512, 1024,2048,4096). Imaginea nu trebuie să fie neapărat pătrată. Dacă dimensiunea imaginii nu este o putere a lui 2, Unity va redimensiona imaginea la cel mai apropiat 2n ca dimensiune, ceea ce poate afecta poza. Ca și excepție de la această regulă, pentru cazul 2D se poate selecta textura și în Inspector se aplică GUI Texture care se referă la elementele folosite pentru interfața cu utilizatorul, cu mențiunea că ideal ar fi să fie de dimensiune pară.

Imaginea ar fi indicat să fie salvată în format PNG și nu în format JPG pentru a nu risca să se piardă din imagine. Pentru a evita probleme ce pot apărea când este mărită imaginea e indicat să setăm dimensiunea imaginii pe 4096 pixeli ca în fig.III.8.

Fig.III.8 Setarea texturii(imaginii) la dimensiunea optimă de 4096 pixeli

Shader definește tipul materialului. Diferitele apariții și look-uri ale obiectelor din joc cer diferite tipuri de material, iar Unity folosește shaders tocmai în acest scop. Dacă textura materialului determină cum se prezintă obiectul la suprafață, shaders sunt cele care determină cum anume se prezintă textura materialului; altfel spus, un material conține proprietăți și texturi, iar shaders dictează care proprietăți și care texturi le poate avea un material.

Nu se pot crea shaders fără material. Majoritatea shaders nu se aplică jocurilor 2D prin urmare e indicat a se seta pe Diffuse în cazul nostru(setarea implicită).

Dacă dorim ca unele materiale să fie imune la luminile scenei putem face asta selectând materialul dorit și apoi setându-i proprietatea Shader pe Self-Illumine > Diffuse ca în fig.III.9 .

Fig.III.9 Setarea materialului selectat, ca imun la luminile scenei

Pentru o transparență optimizată a materialului se va seta Shader pe Unlit > Transparent Cutout ca în fig.III.10 .

Fig.III.10 Setarea materialului pe transparență optimizată folosind Shader

III.3) Realizarea scenelor

Crearea unei noi scene și contabilizarea scenelor create

Crearea unei scene noi se face accesând Meniu > File > New Scene, iar prin salvare se poate da scenei ce nume se dorește. Pentru a le putea ordona și accesa după indice, odată create, scenele trebuiesc adăugate folosind Meniu > File > Build Settings… (fig.III.11).

Fig.III.11 Contabilizarea scenelor

Realizarea scenelor presupune trei aspecte importante și anume GameObjects(elementele folosite), Main Camera(punctul de vedere asupra jocului) și Scripting-ul(care dă comportamentul obiectelor în joc) .

Game Objects

Totul într-un joc se bazează pe Game Objects. Acestea sunt obiecte fundamentale în Unity ce reprezintă caractere, scene, camere, etc. Se comportă ca și containere pentru componente, care implementează funcționalitatea jocului putând fi văzute în Inspector dacă obiectul e selectat.

Fiecare Game Object are un singur component în comun și anume Transform, care înregistrează poziția, rotația și dimensiunea la o anumită scară a obiectului. Pentru duplicarea unui obiect se poate selecta și folosi tastele Ctrl + D.

Un exemplu de folosire a obiectului ar putea fi importarea unui mesh în Unity folosind drag&drop din Project Panel în ViewPort Area, ceea ce reprezintă instanțierea obiectului în scenă. Putem crea mai multe instanțe ale aceluiași obiect folosind drag&drop de mai multe ori.

Main Camera

Este singurul Game Object care nu este creat gol(empty). Reprezintă punctul de vedere al scenei care este arătat jucătorului pe monitor. O scenă poate avea mai multe camere însă doar o singură Main Camera.

Scripting-ul

Reprezintă controlul asupra comportamentului jocului. Codul se poate scrie în C#, JavaScript sau Boo, fiind recomandat a se utiliza un singur limbaj de programare în același joc. Unity folosește MonoDevelop (fig.III.12) ca și editor de cod, open source IDE. Codul poate fi atașat la obiecte ca și componente. Unul dintre avantajele Unity este acela că arată proprietățile publice ale unei clase în Inspector, unde pot fi vizualizare și editate atât la design time cât și la timpul rulării.

Fig.III.12 Editorul de cod MonoDevelop

Componentele unui obiect (clase derivate din MonoBehaviour) pot avea evenimente comune ce reprezintă funcții moștenite din clasa MonoBehaviour ce poate fi suprascrisă în clasele moștenitoare folosindu-ne de metodele Start() și Update(). Funcția Start() este apelată la începutul scenei pentru obiectele mereu prezente. Funcția Update() se apelează o dată pe cadru(frame).

Codul presupune înainte de toate două clase GameManager și Scene Logic. GameManager este o clasă de bază care persistă în toate scenele și controlează logica jocului. Datorită acestei clase informația este procesată pentru a ajunge dispersat la fiecare clasă construită. Scene Logic, pe de altă parte, se folosește pentru logica la nivel de scenă nu la nivel de joc. Vom prezenta în cele ce urmează codul urmând ca fiecare metodă să fie explicată odată cu atașarea la obiectele pentru a căror comportament au fost create.

Clasa GameManager include metodele de schimbare a scenei(SchimbaScena()), de setare a bazei de numerotație(SeteazaBaza()) , de setare a dificultatii jocului (SeteazaDificultatea()) și metoda de ieșire din joc folosită de butonul de Exit( ExitGame()).

Se folosesc două variabile integer publice Baza și Dificultate care se vor putea accesa și modifica din Inspector pentru fiecare din obiectele cărora li se atașează codul. Metodele SeteazaBaza() și SeteazaDificultatea() vor prelua aceste variabile publice pentru a seta după indice, baza și dificultatea.

Metodele SchimbaScena() și ExitGame() folosesc clasa built-in Application ce oferă date privitoare la timpul de rulare prin metodele sale statice. Metoda LoadLevel va încărca scena dorită dupa indicele dat de noi ca parametru iar Quit() va ieși din aplicație.

Metoda Awake() este folosită înainte de Start() și întotdeauna după ce un prefabricat e instanțiat, pentru inițializarea stării jocului și pentru a nu se distruge obiectele odată cu încărcarea unei noi scene, în cazul nostru folosind DontDestroyOnLoad().

Metoda SchimbaScena() se va atașa următoarelor butoane: Play (Scena Start), 2, 8, 16, back (Scena Meniu), Începător, Mediu, Avansat, back (Scena Dificultate), Înapoi la meniu (Scena Final).

Metoda SeteazaBaza() se va atașa următoarelor butoane: 2, 8, 16 din Scena Meniu.

Metoda SeteazaDificultatea() se va atașa butoanelor: Începător, Mediu și Avansat din Scena Dificultate.

Metoda ExitGame() se va atașa butoanelor de Exit din Scena Start, Scena Meniu, Scena Nivel și Scena Final.

În cele ce urmează vom prezenta cum se setează rezoluția jocului, cum se adaugă background-ul la o scenă și cum se folosește Canvasul pentru a adăuga butoanele funcționale.

Rezoluția jocului

Rezoluția jocului este indicat a fi setată la 800×600 astfel încât să se ofere jucătorului posibilitatea de a customiza jocul pentru diferite rezoluții de display, dacă acesta dorește.

Pentru a seta rezoluția dorită folosim Edit > Project Settings > Player (fig.III.13).

Fig.III.13 Setarea rezoluției jocului

Dacă dorim însă ca jucătorul să nu poată schimba rezoluția jocului, punem pe Disabled Display Resolution Dialog (fig.III.14). Astfel ne asigurăm că jocul creat va fi jucat la rezoluția la care a fost creat de programator și la care programatorul s-a gândit că e ideal a fi jucat jocul.

Fig.III.14 Setarea rezoluției de joc pe non-customize

Background-ul

Se referă la fundalul scenelor și avem la dispoziție două opțiuni de setare a acestuia: folosind Main Camera(fig.III.15) sau folosind un sprite 2D căruia îi atribuim cu drag&drop imaginea dorită.

În cazul folosirii Main Camera se poate atribui fundalului doar o culoare anume însă dintr-o paletă variată de culori.

Fig.III.15 Atribuirea unui fundal scenei folosind Main Camera Background

Folosirea unui sprite, pe de altă parte, este un proces mai de durată și se folosește când ne dorim un fundal mai animat. Presupune atașarea unei imagini în Inspector și eventual redimensionarea astfel încât să cuprindă toată aria camerei. În primul rând creăm un sprite folosind Click dreapta > 2D Object > Sprite ca în fig. III.16 și apoi folosim drag&drop pentru a atașa imaginea la sprite ca în fig. III.17.

Fig.III.16 Crearea unui nou sprite

Fig.III.17 Atribuirea unei imagini sprite-ului folosit ca Background

Canvas

Canvas-ul este un obiect container pentru elementele UI(User Interface). Poate conține printre altele butoane, imagini, texte, input text, paneluri, etc. Crearea unui Canvas se realizează accesând din Meniu > GameObject > UI > Canvas. Vom folosi în jocul nostru Canvas-ul pentru a crea butoane de trecere de la o scenă la alta, sau de ieșire din joc și pentru a crea o căsuță de text care să conțină numărul pe care dorim să-l găsim în joc.

Crearea butonului de Play

Se realizează folosind Click dreapta > UI > Button și apoi se poate seta lățimea, înălțimea și locul butonului în Canvas (stanga-sus, stânga-jos, stânga-centru, centru-sus, centru, centru-jos, dreapta-sus, dreapta-centru sau dreapta-jos) (fig.III.18.1). Se poate modifica și culoarea butonului sau atribui diferite efecte acestuia(fig.III.18.2).

Fig.III.18 Setarea butonului Play

Codul folosit pentru comportamentul acestui buton este prezentat în tabelul următor și face parte din clasa principală GameManager care cuprinde metodele de schimbare scenă, schimbare dificultate și ieșire din joc. Metoda SchimbaScena care este apelată la apăsarea butonului Play ia ca parametri numărul scenei la care se dorește să se facă trecerea prin activarea butonului. Metoda folosește clasa built-in Application ce oferă date privitoare la timpul de rulare prin metodele sale statice. Metoda sa LoadLevel folosită de noi va încărca scena dorită dupa indicele dat de noi ca parametru.

Atașarea codului se face cu drag&drop la componenta On Click() a butonului (fig.III.18.3); se alege funcția SchimbaScena() și se dă ca parametru indicele scenei dorite(în cazul nostru 1).

Scena Nivel (jocul propriu-zis)

Folosirea prefabricatelor

De câte ori avem nevoie de un obiect în scenă care poate fi reutilizat de mai multe ori avem nevoie de un prefabricat. Copierea obiectului produce un duplicat, însă acesta este editabil independent. În general noi vrem ca instanțele unui obiect să aibă aceleași proprietăți, astfel încât atunci când setăm proprietățile și componentele unui obiect să nu fim nevoiți să facem aceleași modificări la toate celelalte copii ale obiectului.

Prefabricatele se comportă ca niște șabloane din care se pot crea obiecte noi în scenă prin instanțiere. Orice modificare realizată pe prefab se va reflecta imediat în toate instanțele produse din acesta, dar se pot totuși suprascrie componente și setări pentru fiecare instanță individual.

Crearea unui prefab se face trăgând obiectul din Hierarchy în Asset Panel, ștergerea obiectului din Hierarchy și apoi apoi aplicarea setărilor dorite în Inspector(fig.III.19).

În jocul nostru am folosit prefabricatele la săgețile trase(fiecare tragere constituind o instanțiere a prefabricatului săgeata) și la baloanele apărute.

Fig.III.19 Crearea unui prefabricat

Pentru mișcarea arbaletei cu săgeata după direcția mouse-ului vom folosi codul de mai jos.

Folosim o variabilă de tip float pentru a stabili viteza cu care se va deplasa săgeata.

Apoi într-o variabilă de tipul Vector3 vom pune poziția arcului pentru a o putea modifica.

Variabila de tip Vector3 velocity ne arată parcursul pe axa (Ox a săgeții, folosind viteza săgeții dorită de noi(vitSageata) înmulțită cu timpul trecut de la ultimul Update() dat de Time.deltaTime. Cum noi nu avem o rotație a săgeții(tranform.rotation) săgeata se va mișca tot timpul înainte.

În final se atribuie săgeții(transform.position) poziția luată de la mouse.

Pentru mișcarea baloanelor folosim codul de mai jos.

Se folosește o variabilă publică maxSpeed căruia îi atribuim valoarea vitezei dorite.

Variabilei de tip Vector3 îi atribuim poziția actuală a obiectului folosind transform.position, pentru a o putea modifica.

Vom modifica doar componenta y(pos.y) a obiectului, adică pe direcția în sus a baloanelor aplicându-i viteza pentru fiecare secvență de timp care trece de la ultimul cadru al jocului(Time.deltaTime).

Ulterior atribuim obiectului poziția modificată(transform.position = pos).

Pentru tragerea cu arcul la un click de mouse, în direcția mouse-ului se folosește codul următor:

Avem nevoie de un GameObject public, care să fie referință la săgeata prefabricat, pentru a face copii prin instanțiere.

Variabilei public float fireDelay i se atribuie o întârziere de sfert de secundă la fiecare tragere.

Se inițializează timer-ul de întârziere al tragerii la 0 prin variabila float cooldownTimer.

Variabila publică vieți se folosește pentru a ne spune la coliziune că trebuie autodistrusă săgeata apelându-se funcția Die() ori de câte ori variabila vieți devine mai mică sau egală cu 0.

Folosind funcția Update() fiecare secvență a jocului va realiza următoarele:

scădem timpul trecut de la ultima secvență (cooldownTimer -= Time.deltaTime)

dacă se apasă butonul stâng al mouse-ului și timerul de delay e 0 sau mai puțin, abia atunci avem voie să tragem (if (Input.GetMouseButtonDown(0) && cooldownTimer <=0 ))

în urma tragerii timerul il punem pe cât ar trebui să fie întârzierea între trageri (cooldownTimer = fireDelay)

la fiecare tragere instanțiem o copie a prefabului săgeată la poziția de tragere a arcului (Instantiate (sageataPrefab, transform.position, transform.rotation))

În final funcția Die() face ca obiectul să nu mai existe pe scena jocului prin apelul funcției built-in Destroy().

Fizica jocului 2D prin Collider și Rigidbody

Collider este folosit în Unity pentru pentru a determina coliziunea când lucrurile se mișcă folosind sistemul fizic.

Rigidbody dă masă obiectelor și le atașează legile fizicii.

Collide presupune lovire, Rigidbody presupune masă și gravitație.

Pentru a aplica un Collider2D sau RigidBody2D unui obiect, se selectează obiectul și apoi în Inspector se folosește Add Component > Physics 2D ca în fig. III.20.

Fig. III. 20 Adăugarea la un obiect a componentelor Collider2D și RigidBody2D

Collider2D presupune o variabilă booleană Is Trigger(fig.III.21) care odată bifată în Inspector(setată pe true) face ca obiectul să nu interacționeze cu fizica în niciun fel, însă ne ajută să ne dăm seama dacă un obiect fizic trece prin el. Apare ca un elemente static dacă se trece prin el.

Collider2D aplicat obiectelor poate fi de 4 feluri:

Box Collider se aplică obiectelor de formă rectangulară;

Circle Collider se aplică pentru obiectele circulare;

Edge Collider presupune linii conectate și vârfuri care pot fi redimensionate;

Polygon Collider presupune un poligon a cărui linii și vârfuri pot fi modificate.

În cazul nostru am folosit Box Collider la baloanul prefabricat și Polygon Collider la săgeata prefabricată.

Fig.III.21 Aplicarea Is Trigger la un obiect

RigidBody2D are de asemenea o variabilă booleană Is Kinematic(fig.III.22) care se va aplica obiectelor care vrem să fie văzute din punct de vedere al fizicii dar să nu fie afectate de forțe. Cu alte cuvinte poate afecta, dar nu e afectat.

Fig. III.22 Aplicarea Is Kinematic unui obiect

Pentru a nu se lovi obiectele de același tip care au Collider2D și RigidBody, vom folosi Layer. Adăugarea unui Layer se face folosind în Inspector Layer > Add Layer… ca în fig. III.23.

Fig.III.23 Adăugarea unui Layer

Ulterior se accesează de la setări Pysics2D(Edit > Project Settings > Pysics2D) ca în fig.III.24 și în Inspector se debifează căsuțele pentru a nu se aplica Collider în caz de intersecție la obiectele dorite(fig.III.25).

Fig.III.24 Setarea preferințelor de fizică 2D

Fig.III.25 Matricea setărilor coliziunilor în funcție de Layer

Pentru distrugerea baloanelor și a săgeților în cazul coliziunilor vom folosi următoarea secvență de cod:

Folosim o variabilă integer care să pastreze numărul de vieți ale obiectului.

În cazul în care se intâlnesc 2 obiecte care au boxcollider 2D, prin apelul metodei OnTriggerEnter2D() se va scădea numărul de vieți ale obiectului.

Pentru fiecare cadru al jocului prin metoda Update(), dacă obiectul nu mai are vieți se apelează metoda Die().

Metoda Die() odată apelată face ca obiectul să nu mai existe pe scena jocului prin apelul metodei built-in Destroy().

CONCLUZII

În urma folosirii game engine-ului Unity pentru a crea un joc în 2D vom prezenta pentru final câteva concluzii expunând unele din avantajele și dezavantajele găsite privitoare la utilizarea Unity.

Avantaje

+ În prezent avem la dispoziție o varietate largă de cărți și video-uri care ne pot ajuta să realizăm cap – coadă jocuri 2D sau 3D folosind Unity. Un avantaj pe care îl au cărțile, însă, în raport cu video-urile este că poate oferi mai multe explicații.

+ Oferă suport „out of the box” pentru o mare varietate de platforme și în plus pot fi ușor și repede portate pe altă platformă (cross-platform).

+ Folosește un singur editor pentru toate platformele, ce are bine implementate caracteristile cele mai des întâlnite.

+ Asigură o licență gratuită care acoperă majoritatea caracteristicilor necesare. Licența care se plătește este la un preț avantajos de $75 pentru o platformă (unele platforme fiind gratuite).

+ Asigură o mare varietate de platforme, mobile, desktop, web și console și în același timp o mare varietate de formaturi de asset-uri pe care le transformă automat în formatul optim pentru platforma dorită.

+ Comunitatea answers.unity3d.com oferă o multitudine de informații și soluții la îndemână.

+ Partea vizuală este extraordinară oferind efecte avansate cu suport de materiale și un drăguț editor ce poate fi extins folosind pluginuri. Rezoluția se poate redimensiona ușor pentru mobile oferind suficient acces low-level pentru optimizare.

Dezavantaje

– Nu asigură suport 2D suficient, însă luând în considerare faptul că a fost creat în special pentru jocurile 3D se poate omite acest minus.

– Varianta gratuită nu asigură suficient suport multi-developer.

– Codul sursă al engine-ului nu este disponibil nici măcar pentru userii care plătesc să vadă codul sursă Unity, ceea ce înseamnă că dacă dai peste un bug trebuie să aștepți ca ei să rezolve problema sau să căutăm altă soluție ocolitoare.

– Performanța lasă puțin de dorit, iar la capitolul built in GUI stă cam prost fiind bun pentru prototipurile rapide și nu prea pentru restul.

În final luând în considerare toate aceste avantaje și dezavantaje Unity, și în urma folosirii acestui game engine pentru crearea jocului expus în prezenta lucrare, am ajuns la concluzia că Unity salvează timpul programatorului oferindu-i posibilitatea să se concentreze pe jocul însuși și nu pe detalii precum grafică sau networking.

Unity îți dă acea unică impresie că odată ce știi cum funcționează, îți dai seama că e o soluție briliantă pe care nu prea ai chef să explici altcuiva de ce funcționează, ci mai degrabă îți folosești timpul tău creând jocuri.

BIBLIOGRAFIE

Cărți

Jebediah Pavleas, Jack Keng-Wei Chang, Kelvin Sung și Robert Zhu – „Learn 2D Game Development with C#”, Editura Apress, 2013, Ediția 1 (în limba engleză)

Arjan Egges, Jeroen D. Fokker, Mark H. Overmars – “Learning C# by Programming Games”, Editura Springer, 2013 (în limba engleză)

Alan Thorn – “Learn Unity for 2D Game Development”, Editura Apress, 2013, Ediția 1 (în limba engleză)

Sue Blackman, Jenny Wang – “Unity for Absolute Beginners”, Editura Apress, 2014 (în limba engleză)

Internet

https://unity3d.com/

Site-ul producătorului Unity Technologies

http://en.wikipedia.org/wiki/Unity_(game_engine)

Enciclopedie online

http://stackoverflow.com/

Site de întrebări și răspunsuri pentru programatori

http://answers.unity3d.com/

Comunitate internațională de programatori Unity

http://docs.unity3d.com/ScriptReference/

Site cu doumentație oferit de Unity

http://www.informit.com/articles/article.aspx?p=2162089&seqNum=2