Aplicație Grafică de Rpg (role Playing Game) în Unitydocx

=== Aplicație grafică de RPG (Role Playing Game) în Unity ===

Universitatea din Pitești

Facultatea de Matematică-Informatică

Domeniu de licență Informatică

LUCRARE DE LICENȚĂ

Aplicație grafică de RPG (Role Playing Game) în Unity

Coordonator, Absolvent,

Lect. univ. dr. Maria Miroiu TUȚĂ Ciprian-Mihăiță

Pitești, 2016

Cuprins

Introducere ..…………………………………………………………..……………… 2

Capitolul 1 ……………………………………………………………………………… 3

MOTOARE GRAFICE…………………………………………………………. 3

1.1 Noțiuni și generalități……………………………………………………… 3

1.2 Componentele principale ale unui motor grafic………………….………. 7

Capitolul 2 ……………………………………………………………………………. 10

MOTORUL GRAFIC UNITY ……………………………………………… 10

2.1 Bazele folosirii Unity ……………………………………….….………. 10

2.2 Asseturile în Unity ………………………………………….…….……. 14

2.3 Funcționalități de bază ………………………………….………….…….. 19

2.4 Input – Elemente de intrare ………………………………….….……… 22

2.5 Elemente RNG …………………………………………………………. 25

2.6 Utilizarea luminilor ……………………………………………………… 28

2.7 Camera și manipularea ei ……………………………………………………. 30

2.8 Unity în 2D …………………………………………………………….. 32

2.9 Legile fizicii în Unity …………………………………………….…….. 34

2.10 Scripturile în Unity ……………………………………………….……38

2.11 Rețea cu mai mulți jucători (Multiplayer) …………………………….. 49

2.12 Sunetele în Unity ………………………………………………….….. 50

2.13 Opinia și concluzie …………………………………………………… 52

Capitolul 3 ……………………………………………………………………………. 53

APLICAȚIE – JOC RPG ……………………………………………………53

3.1 Meniu Principal ……………………………………………………….. 55

3.2 Interioul jocului ……………………………………………….………..56

3.3 Partea tehnică a jocului ………………………………………………..58

BIBLIOGRAFIE …………………………………………………………………… 62

INTRODUCERE

Termenul de grafică pe calculator include aproape totul ce nu ține de text sau sunet. Astăzi, aproape orice calculator poate face niște grafică, făcând posibilă controlarea calculatorului prin intermediul pictogramelor și a pozelor care este mai avantajos decât simpla tastare pe calculator. Generarea unei poze de orice mărime pe un ecran de calculator este un proces dificil tocmai de aceea intre în rol grafica pe calculator care are în componență anumiți algoritmi și tehnici care ajută la generarea lor pe calculatoare. Grafica pe calculator este arta desenării pozelor pe ecranele calculatoarelor cu ajutorul programării prin intermediul unor computații, creații și manipularea datei. Prin asta am putea spune că grafica pe calculator este o unealtă de generare și manipulare a imaginilor. O principală utilizare a graficei pe calculator este crearea de jocuri video unde putea creea o lume imaginară formată numai din obiecte modelate grafic. Practic, dăm viață imaginației noastre cu ajutorul programării și modelării unor linii și puncte. Ca să fim ajutați, au fost create motoarele grafice care sunt o componentă principală în realizarea oricărei aplicație grafice pe calculator.

Motorul grafic sau în cazul nostru un motor de jocuri este o invenție chiar recentă. Cu ajutorul lui, putem realiza jocuri prin interacțiunea utilizatorului cu elementele și funcțiile specifice motorului. Înainte, motoarele grafice erau încă primitive neavând multe caracteristici ,instrumente și funcții avansate de prelucrare a mediului, dar cu timpul, acestea au evoluat și ce a rezultat a uimit o întreaga comunitate de oameni ambițioși care a dat naștere multor companii de jocuri care la rândul lor și-au creat propriul motor grafic pentru a fi folosit în viitoarele lor proiecte. De obicei, compania are o echipă specializată în crearea de grafică, care după ce au terminat, dă mai departe munca lor spre celelalte ramuri a companiei.

În cadrul lucrării, voi evidenția pe parcursul a trei capitole, tot ce trebuie să se știe despre un motor grafic, despre Unity, un motor grafic apărut în deceniul trecut și o aplicație realizată în acest motor grafic. Pe scurt, fiecare capitol prezintă:

Capitolul 1 – “Motoare Grafice” prezintă întreaga istorie al unui motor grafic și tot ce se poate realiza cu ajutorul lui, de asemenea voi evidenția și componentele lui care ajută la îndeplinirea oricărui obiectiv al utilizatorului.

Capitolul 2 – “Motorul Grafic Unity” unde voi prezenta fiecare componentă a motorului grafic creat de compania Unity Technologies. Voi oferii în detaliu cu ajutorul unor capturi de ecran, ce se poate realiza cu fiecare componentă a motorului grafic.

Capitolul 3 – “Aplicație – Joc RPG” unde prezint în detaliu o aplicație realizata de mine în versiunea de Unity 4.6 într-un mediu 3D.

Capitolul 1

Motoare grafice

1.1 Noțiuni și generalități

Motorul grafic – se folosește în crearea și dezvoltarea de jocuri video folosind un sistem specific lui. Jocurile create pot fi folosite pe mai multe platforme numite și console de jocuri (Playstation , Xbox, Wii etc.) sau direct la calculatoarele noastre personale.

Ai putea spune ca motorul grafic este la fel ca un motor de mașină oarecare pentru ca face ca jocul să meargă. Fără acel motor grafic, jocul nu se poate manifesta pe ecran la fel cum o mașină nu poate pornii fără să aibă benzină sau în rare cazuri un motor sub capotă. în general, conceptul de motor grafic este chiar foarte simplu. El abstractiză detalii în a face diverse obiective legate de jocuri ca de exemplu rendare, aplicarea legilor fizicii în jocuri și introducerea de date de intrare în calculator. Astfel, dezvoltatorii din care fac parte artiștii,designerii,scripterii și programatorii se pot concentra la detaliile în a face jocul lor ceva unic.

Unity 3D este un puternic motor de grafică 3D care se poate folosii pe mai multe platforme și mediul de lucru este unul prietenos cu utilizatorul dezvoltator. Este ușor de folosit de către începători și destul de puternic pentru a da provocări și de către experți. Unity ar trebui să intereseze pe oricine care vrea să creeze cu ușurință jocuri 3D și aplicații pentru mobil, calculatoare personale, situri web și console.

Inițial anunțat doar pentru OS X, la convenția internațională a dezvoltatorilor susținută de Apple Inc. în anul 2005, Unity de atunci a fost extins să funcționeze pe 21 de platforme. Este de asemenea componenta principală de dezvoltare software (SDK) pentru consola creată de compania Nintendo, Wii U.

În prezent, cinci mari versiuni ale lui Unity au fost lansate pe piață. În cadrul convenției următoare din 2006, Apple Inc. a numit Unity „Cel mai bun utilizator de Mac OS X” în cadrul categoriei de grafică.

Unity pune accentul pe portabilitate și țintește următoarele interfețe de programare de aplicații (API) : Direct3D pe Windows și Xbox 360; OpenGL pe Mac și Windows; OpenGL ES pe Android și iOS; și API proprietar pe consolele de jocuri video. Unity permite specificația de compresiune a texturii și setarea de rezoluție pentru fiecare platformă pe care jocul o suportă, de asemenea oferă și suport pentru cartografie de proeminență, cartografie de reflecție, cartografiere paralaxă, ambientarea spațiului ecranului folosind ecloziune (SSAO), umbre dinamice folosind hărți de umbre, rendare-spre-texturi și efecte post-procesate când ecranul este pe la rezoluție maximă. Diversitatea platformelor motorului grafic al lui Unity oferă și un shader (umbră) cu multiple variante și un specificator declarativ tip retragere(fallback), care permite lui Unity să detecteze cea mai bună variantă pentru cardul video curent, iar dacă niciunul din acestea nu este compatibil, se va retrage la un shader alternativ care din păcate sacrifică unele funcționalități pentru performanță.

Unity este notabil pentru abilitatea lui de a țintii jocuri spre mai multe platforme. În cadrul unui proiect, dezolvotatorii au control asupra livrării către instrumente mobile, browsere-le web, calculatoare personale, și console. Platformele suportate de Unity includ : Android, Apple TV, BlackBerry 10, iOS, Linux, gama Nintendo 3DS, OS X, Playstation 3, Playstation 4, Playstation Vita, Unity Web Player (care include și Facebook), Wii, Wii U, Windows Phone 8, Windows, Xbox 360, și Xbox One. Include de asemenea și un server de aserturi și motorul de legi de fizica PhysX creat de Nvidia. Unity Web Player este o extensie de browser care este suportata doar pe Windows și OS X. Din păcate, Unity Web Player a fost depreciat în favoarea lui WebGL și încetul cu încetul devine înlocuit. Unity este soft-ul implicit de dezvoltare (SDK) pentru consola Wii U creată de către Nintendo, care include o copie gratuită introdusă de Nintendo pentru fiecare licență de dezvolvator. Unity Technologies numește acest pachet de terță SDK un “primul în industrie”

În Japonia, Unity are o mascotă specifică culturii “moe” a japonezilor, numit Unity-chan, numele real fiind Kohaku Otori. Compania permite folosirea lui Unity-chan și alte personaje care au legătură cu asta în proiecte secundare sub anumite licențe. De exemplu, Unity-chan apare ca personaj jucabil în jocul Runbow. Popularitatea caracterului a dus de asemenea în apariția ei în adaptări Vocaloid, incluzând propria biblioteca de sunete pentru Vocaloid 4 și o adaptare specială a lui Vocaloid creată să funcționeze cu Unity Engine 5.0 numită “Unity cu Vocaloid”

Ultima versiune de Unity este Unity3D 5.(xx) care include noi funcționalități față de versiunile anterioare și o interfață cu totul nouă. Versiunile trecute ale lui Unity sunt încă și astăzi folosite în jocuri care nu necesită multe obiecte, efecte sau scripturi în general. Este de știut ca Unity oferă orice versiune prin intermediul magazinului de pe situl principal, dar ne este recomandat de către companie ca oricând am reușit să devenim experți la o anumită versiune, să încercăm și versiunile anterioare și viitoare pentru a vedea ce s-au schimbat de-a lungul anilor la funcționalități și modul cum soft-ul interacționează cu utilizatorul.

Unity nu este singurul pe piață care oferă un motor grafic inteligent și ușor de folosit. De-a lungul anilor, companii similare au scos propriul lor motor grafic pentru a fi în competiție unul cu altul. Cele mai populare motoare grafice din punctul de vedere al funcționalității și popularității sunt :

Unreal Engine (ultima versiune fiind UDK 4) dezvoltat de către compania Epic Games

Cry Engine dezvoltat de compania Crytek

Source 2 dizolvat de compania Valve Corporation

În principal, competiția adevărată este intre Unity și Unreal Engine deoarece amandouă oferă aceleasi funcționalități dar cu mici diferențe în programare și modul de interacționare cu utilizatorul.

Ca să programezi în Unity nu îți trebuie doar cunoștințe în limbajele de programare UnityScript/C# . Unity detectează dacă ai instalat un compilator care folosesc acele limbaje și imediat ce începi să programezi de exemplu un script, Unity va deschide automat acel compilator. Implicit, Visual Studio creat de Microsoft este cel mai des folosit în crearea de scripturi pentru Unity deoarece ofera și crearea unui proiect de tip Windows Form care poate fi integrat ușor în Unity cu ajutorul unui importator din cadrul programului.

Motoarele Grafice folosesc scripturi pentru fi implementate în joc și au rolul în a crea lumea din cadrul jocului. De exemplu, se poate crea un script care ajută la animația norilor de pe cer. Imedait după ce scriptul a fost implementat, se poate atribuii usor unui obiect din cadrul proiectului Unity pentru a fi manipulate mai departe. Acest lucru nu se rezuma doar la animație, acestea pot influența și gameplay-ul jocului, adică modul cum jucătorul interactioneză cu mediul din jurul lui și chiar și pe el însuși prin realizarea de scirpturi care ajuta la mișcarea personajului în joc și cel fel de acțiuni poate face (alergare, urcare, sarire etc.)

Celelate motoare de căutare (exemplu Blueprint la Unreal Engine 4) oferă aceleași metode de realizare de scripturi , singura diferență fiind modul cum acestea sunt applicate în cadrul jocului.

În următoarele imagini, voi evidenția, ce fel de animații se pot face în cadrul spațiului de lucru din Unity. Toate motoarele de grafică au incorporate o astfel de funcționalitate pentru a da viață jocului creat de utilizator.

Este de știut că Unity are încorporat și recunoaștere facială prin intermediul camerei web unde fața este scanată și importată ca model 3D în cadrul editorului de personaje din Unity.

Cum am spus mai sus, Unity nu este restâns doar la a face personaje. Poți de asemenea să manipulezi însăși natura prin crearea de ploi, tornade, ninsori și în general toatefenomenele dezastruoase din natură.

Licențierea soft-ului a evoluat de-a lungul anilor de la un simplu motor grafic de realizare a unor animatii de către dezvoltatori indie, către un motor grafic folosit la scală largă de toate tipurile de utilizatori. În cadrul acestei secțiuni vor fi luate în considerație unele fapte precum prețul și dreptul de proprietate.

Unity este printre singurele motoare grafice căutate cel mai mult de către dezvoltatorii indie pentru ca este gratis. Pentru cei care caută să realizeze un proiect mai avansat, Unity oferă o versiune Pro care conține mai multe funcționalități și unelte la prețul total de 1500$. Considerant funcționalitățile și cât de permisibil este Unity în licența de publicare, prețul este chiar foarte rezonabil. Totuși, versiunea gratis îți va permite să realizezi un joc la scală largă (complet) și chiar să-l publici pe spațiul de lucru și pe internet fară să da-i nici un ban! Singurul dezavantaj e că jocurile publicate sub licența gratis va avea un mic filigran pe ecran.

Totul construit în Unity va funcționla la fel ca în Unity Pro. Asta înseamnă ca poți alege oricând să actualizezi programul dacă ai nevoie de funcționalități adiționale, sau vrei să publici către mai multe platforme ca de exemplu iOS și Android. Este de asemenea și o modalitate de a încerca varianta Pro pe gratis timp de 30 de zile prin înregistrarea pe site pentru a teste toate funcționalitățile care le oferă.

Cât despre cat de apreciat este Unity de către consumatori, recenziile ne arată că în 2012, Unity a ajuns la punctul critic în cariera sa de program. Venture Beat, un site cunoscut pentru recenzii despre orice legat de domeniul IT a spus “Puține companii au contribuit la numărul de jocuri create independent la fel ca Unity Tehchnologies…Mai mult de 1.3 milioane de dezvoltatori folosesc intrumentele sala pentru a crea miracole grafice în jocurile lor iOS, Android, console, calculatoare personale și jocuri integrate web…Unity vrea să fie motorul grafic pentru jocuri pe platforma multiple la sigur!”

Dar există și critică negativă ca la orice program software. Unity Technologies a fost critizat în urma multor jocuri produse și distribuite pe platforma Steam de către dezvoltatori neexperimentați care ofereau jocuri neinovative create doar pentru consum și fără originalitate, nu și pentru a oferii noi modelatitați de folosire a programului.

1.2 Componentele principale ale unui motor grafic

Inițial motoarele grafice aveau doar cateva componente necesare programării, dar cu timpul, noi funcționalități au fost adăugate care ori au actualizat componentele actuale, ori au adăugat unele noi. În zilele moderne motoarele grafice au în alcătuință următoarele componente care le oferă utilizatorului

Rendarea – componentă principală al oricărui motor grafic. Acest lucru face posibilă apariția obiectului pe ecran prin generarea unui imagini de la un model sau scenă 2D sau 3D. Un fișier scena conține obiecte definite scrict în limbă și structuri de date; poate conține informații geometrie, texturi, luminozitate sau umbrire care descriu scena virtuală. Cu cât grafica are calitate mai înaltă, cu atât va atrage mai mulți consumatori pentru a cumpăra produsul creat de dezvoltator. Multe jocuri moderne folosesc grafice superbe care sunt foarte aproape de felul cum arată realitatea.

Animația – procesul folosit pentru generarea de imagini animate fie ea 2D sau 3D. Un joc nu poate fi static, așa că, putem introduce animații grafice care da viață lumii din jurul scenei pentru a face jocul cat mai realist. Cea mai de bază animatie este mișcarea personajului tau unde ii oferi posibilitatea de a se mișca de pe loc, să privească în jurul lui și cel mai important, să interactioneaze cu mediul din jurul lui cum ar fi citirea unui cărți.

Inteligența artificială – reprezință mintea din interiorul lumii create de dezvoltator. Orice personaj sau obiect înafară de personajul controlat de utilizator, au o minte proprie în care sunt programați să facă o anumită acțiune în funcție de anumți factori care se schimba în cadrul scenei. De exemplu, personajul care îl controlezi, poate purta o conversație cu un alt personaj programat să răspundă cu anumite replici și gesturi.

Video – sunt filmutețe create de către dezvoltator care oferă jocului un mod de prezentare a poveștii care se întâmplă în joc, sau un un moment de avansare a poveștii atunci cand jucătorul a ajuns la o anumită scenă sau a efectuat o anumită acțiune.

Coloana sonoră – degeaba există animație dacă nu putem auzi și ce fel de sunete produc acele obiecte. Motoarele grafice oferă jucătorului un mod de a se imersiza în lumea jocului prin diverse melodii, sunete și efecte create de dezvoltator. Acestea pot fi 2D sau 3D, iar cele 3D oferă realism datorită faptului că simulează cum ar putea suna acel sunet dacă ar fi aproape de jucător sau la depărtare. Melodiile au scopul de a da atmosferă zonei în care se află jucătorul ca de exemplu vizitarea unui oraș sau lupta cu un monstru.

Scriptul – dacă vrei ca nivelul tau sau în general tot jocul să funcționeze automat în funcție de cum decide dezvoltatorul, sunt necesare anumite scripturi care fac jocul să fie cât mai interesant și dinamic pentru a captiva jucătorul să continue să joace acel joc. În general, scripturile este reprezentat intr-un mediu de programare cu un limbaj de scripting visual care au scopul de a permite unele acțiuni din joc să fie efectuate cu succes fără a fi întrerupt de către anumiți factori și să ofere jucătorului noi căi de a efectua o anumită acțiune ca de exemplu să ridice un obiect de pe jos cu mâna sau cu piciorul.

Aplicarea legilor fizicii – dezvoltatorii țintesc să-si facă jocurile cât mai realiste trebuesc aplicate legile fizicii care includ detectarea și interacțiunea dintre doua obiecte prin folosirea de coloziune. Intr-o lume 2D, este suficient să fie adăugată gravitația și coleziunea între doua obiecte, dar intr-o lume 3D, trebuie adăugate cât mai multe fenomene fizice din realitate pentru a face jocul cât mai realist. Multe companii de-a lungul timpului au încercat metode noi de aplicare a lor pentru a face jocătorul cat mai atras de ce se întamplă în joc și să se simtă că face parte din acea lume fără a întâmpina ireguralități pe unde merge. Aceste ireguralități sunt de obicei bug-uri sau erori de coleziune care permit jucătorului să pătrundă în zone inacsibile de către acesta și să strice toată atmosfera creată de către joc. Fără coleziune, jucătorul poate trece prin pereți, obiectele s-ar contopii unul cu altul atunci cand se lovesc și fără gravitație personajul jucătorului ar putea plutii în jurul hărții exploatând astfel animte hazarde sau capcane create de către dezvoltator. Desigur, acest lucru poate fi chiar o funcționalitate a jocului unde personajul controlat de jucător are puterea de a sfida legile fizicii și să-i permită să treacă prin pereți ca o fantomă sau nivelul se petrece în spațiu unde nu există gravitație și jucătorul plutește în gol în spațiul infinit.

Intrumente și unelte – Unity și în general fiecare motor grafic în parte, oferă dezvoltatorului o gamă largă de instrumente și unelte care ajută la programarea cât mai ușoară a mediului în care lucrează. Acestea pot fi de multe tipuri cum ar fi plasarea cât mai ușoară a obiectelor, programarea inteligenței artificiale să fie facută pe o anumita categorie de obiecte instant, modificarea locației, a formei și a materialului fără a afecta scriptul aplicat pe acel obiect. Inițial, scena este goală, dar după ce se umple, devine deficil să ții pasul cu fiecare lucru programat, inserat sau modelat. Așa că , motorul grafic oferă o interfață usor de folosit care îi arată dezvoltatorului tot ce trebuie să facă ca să-și optimizeze proiectul și să nu se încurce atunci când este foarte dezvoltat.

In principal, astea sunt componentele de bază al oricarui motor grafic modern. Recent, după apariția tehnologiei VR- Virtual Reality (Realitate Virtuală), motoarele grafice încep să-și integreze și funcționalitatea de a fi compatibile cu acele dispozitive VR care introduc jucătorul direct în joc prin ochii săi. În curând, va fi posibil să mirosim, simtim, mișcăm cu ajutorul părților corpurilor noaste tot ce este în joc datorită acestei tehnologii care are scopul de a ne introduce într-o lume cât mai realistă a jocului.

În încheierea acestui capitol vreau să aduc la cunoștință din nou faptul că motoarele grafice vor evoluea în continuare, fie cu noi funcționalități, fie doar cu anumite actualizări și rezolvari de erori. Cred cu tărie ca în următoarele decenii, fiecare om capabil să folosească un calculator, va putea folosii un motor grafic să-și creeze propria sa lume imaginară unde să se relaxeze și să experimenteze cum este să fac parte dintr-o lume a fantasmului care există doar în cărți.

Capitolul 2

Motorul grafic unity

Unity este un motor grafic gratuit oferit de cei de la Unity Technologies pentru a fi folosit în realizarea de aplicații 2D sau 3D. Poti crea cu ușurință, poți să o faci într-un mod foarte optimizat și frumos orice fel de joc la care dezvoltatorul are inovație. Cu un singur click, poți porta usor jocul pe mai multe plaforme, practic ai lumea virtuală la degetele tale. Cu atât mai mult, Unity are integrat servicii care te ajută să

mărești procesul de dezvoltare, de optimizare a jocului, conectarea cu audiență care în final îți ofera un succes garantat.

Ultima versiunea de Unity, și anume Unity 5, oferă o gamă larga de funcționalități perfecte pentru a crea orice fel de joc. În următoarea secțiune, voi prezenta fiecare component și instrument care sunt prea complexe pentru a fi doar enumerotate. Voi prezenta felul cum scripturile sunt create și aplicate, cum sunt manipulate obiectele în program într-un mediu 2D și 3D, cum se poate optimiza ușor un proiect și în final, cum putem învăta o persoană complet neexperimentată în programarea grafică în așa fel să poată folosii Unity să creeze primul său joc.

2.1 Bazele folosirii Unity

Descarcare și Instalare Unity

Poți descărca și instala editorul Unity direct de la pagina principala a sitului web al companiei. Instalatorul folosește un Asistent de Descărcare și are instrucțiuni detaliate pe care poți să le urmezi cu ușurință. Există de asemenea și obțiunea de a instala editorul folsint un torrent sau chiar să instalezi versiuni multiple de Unity, nu vor exista niciodata conflicte înafara faptului că versiunile vechi duce lipsă de unele functionalități.

Incepând de la versiunea 5.0 în sus, Unity a început să folosească un program executabil de instalare (aproximativ 1 MB în mărime) care te lasă să alegi ce componente din editor vrei să descarci și să instalezi. Dacă nu ești sgur de care componente vrei să le instalezi, lasă selectiile implicite asa cum au fost setate inițial de instalator.

Există obțiunea de a instala Unity și fără asistent, poți descarca componentele care sunt sub formă de pachete și programre executabile separat, dar este recomandat dacă ești utilizator nou să folosești asistentul.

Poți de asemenea să instalezi Unity din command prompt folosind linii de comandă specifice lui.

Proiecte 2D sau 3D

Unity este folosit în egală măsură pentru a crea jocuri 2D, 3D, dar și o combinație a lor. Care esti diferența? Când creezi un nou proiect în Unity, ai de ales să începi în modul 2D sau 3D. S-ar putea ca deja să știi ce ai vrea să construiești, dar există unele puncte subtile care ar putea afecta ce mod vrei să folosești.

Alegerea dintre a începe în modul 2D sau 3D determină niste setari pentru editorul Unity, ca de exemplu daca imaginile importate sunt texture sau sprite-uri. Nu-ți face griji dacă faci alegerea greșită, poți schimba între 2D și 3D oricând chiar dacă deja ai setat din deja pentru proiect.

Urmează să exemplific fiecare mod grafic pe care îl poti seta atunci cand pronești proiectul.

FULL 3D

Jocurile 3D de obicei folosesc geometria în plan, cu materiale și texture renduite pe suprafața acestor obiecte ca să pară medii solide, personaje și obiecte care compun lumea jocului tău. Camera se poate mișca peste tot într-un mod liber, cu lumini și umbre puse în jurul lumii într-un mod realistic. Jocurile 3D renduiesc scena folosind perspectiva, deci obiectele apar mai mari pe ecran cu cât se aproprie mai mult de cameră.

3D ORTOGRAFIC

Câteodată jocurile folosesc geometrie 3D, dar folosesc o camera ortografică în loc de cea perspectivă. Aceasta este o tehnică folosită în jocuirle care îți dă o privire de “pasăre” a acțiunii, fenomen numit și “2.5D”. Dacă faci un joc acesta, ar trebui să foloșesti editorul în modul 3D, pentru că chiar dacă nu este o perspectivă, tot vrei lucra cu modele 3D și asseturi. Va trebui să-ț schimbi camera și vederea scenei pe Ortografic pentru a putea continua.

FULL 2D

Multe jocuri 2D folosesc grafice plate, cateodată numite sprite-uri, care nu au nici o geometrie plană în componența sa. Sunt desenate pe ecran ca imagini plate, iar camera jocului nu are nici o perspectiva. Pentru acest tip de joc, trebuie să pornesti proiectul un modul 2D.

GAMEPLAY 2D CU GRAFICĂ 3D

Unele jocuri 2D folosesc geometria 3D pentru mediul înconjurătorul și personaje, dar restricționează gameplay-ul pe două dimensiuni. De exemplu, camera poate arăta o “vedere laterală derulantă” iar jucătorul se poate mișca doar în doua dimensiuni, dar jocul încă folosește modele 3D pentru obstacole și perspectiva 3D pentru cameră. Pentru aceste jocuri, efectul 3D are efect stlistic decât funcțional. Acest tip de joc este uneori referit și ca “2.5D”. Chiar dacă gameplay-ul este 2D, vei manipula consistent modele 3D pentru a contrui jocul, asa că va trebui să intrii în modul 3D.

GAMEPLAY ȘI GRAFICĂ 2D CU O CAMERĂ PERSPECTIVĂ

Acesta este încă un alt mod popular de joc 2D folosind grafică 2D dar o cameră perspectivă pentru a obține efectul de defilare paralaxă. Acesta este un stil de scenă “teatru de carton” unde toată grafica este plată, dar aranjată la distanțe diferite de la cameră. Pentru acest mod, 2D-ul este cel mai potrivit pentru a dezvolta și să schimbi modul cum camera se proiectează pe perspectivă și vederea scenei pe 3D.

2.2 Asseturile în Unity

Un asset este reprezentarea oricărui obiect care poate fi folosit în jocul sau proiectul tău. Un asset poate provenii de la un fișier creat înafara lui Unity, ca de exemplu un model 3D, un fișiser audio, o imagine, sau oricare dintre tipurile de fișiere pe care Unity le suportă. Există de asemenea și unele tipuri de asset-uri care pot fi create în Unity, ca de exemplu “Animator Controller” (Controlorul Animatorului) , un Audio Mixer (Mixer de audio) sau Render Texture (Renduire Textură)

Figura 2.1 – Exemplu de fereastră de asseturi

Unity poate funcționa cu modele 3D de toate felurile care pot fie create de software-uri de modelare. Totuși, există un numar de tipuri de obiecte primitive care pot create direct în Unity. Aceste obiecte sunt de obicei folositoare pentru crearea de obiecte simple care nu necesită modelare personalizată. Oricare dintre aceste primitive pot fi adaugate în scenă folosind instrumentele din cadrul programului.

Figura 2.1.1 Cub Primitiv

Figura 2.1.2 Sferă Primitivă

Figura 2.1.3 Capsulă Primitivă

Figura 2.1.4 Cilindru Primitv

Figura 2.1.5 Plan primitiv

Figura 2.1.6 Quad Primitiv

Importarea asseturilor

Asseturi create înafara lui Unity trebuiesc introduse în Unity ori prin salvarea fișieurului în folderul Assets al proiectului tău, sau copiat în acel folder. Pentru multe formate comune, poți salva fișierul tău sursă direct în folderul tău de Assets iar Unity îl va putea citi. Unity v-a observa când salvezi noi modificări la fișier și va putea reimporta dacă este necesar.

Figura 2.1.7 Locatia folderului Assets

Figura 2.1.8 Asseturi importate

Tipurile de asseturi care pot fi importate depind de natura lor. În următoarele rânduri voi enumera tipurile de fișiere ce pot fi importate.

Fișiere Imagine – Cele mai comune tipuri de imagine ca BMP, TIF, TGA, JPG și PSD sunt suportate de către Unity.

Fișiere de modele 3D – Folosind funcția de export din cadrul programului de modelare 3D, putem folosii FBX plugin ca să le putem face importabile în Unity.

Plase și Animații – oricare pachet 3D ai folosii, Unity va importa plasele și animațiile de la fiecare fișier.

Fișiere audio – Dacă salvezi fișiere audio necompresate în folderul tau de Assets, ele vor devenii importate în funcție de setările de compresie specificate.

Figura 2.1.9 Asset imagine importată

Figura 2.1.10 Asset sunet imporat

Unity dispune de un magazin de assets numit “Asset store” unde se pot descarca pachete de asseturi care pot fi importate în fereastra de Assets. Există pachete gratis care poate fi folosit de orice utilizator fără probleme de drepturi de autor și cele care pot fi cumpărate care conțin modele foarte detaliate de obiecte, personaje care vor imbunătății proiectul tău.

Cu timpul, aceste asseturi vor fi actualizate de către creatori pentru a fi folosite în versiunile viitoare din Unity.

2.3 Funcționalități de bază

Scena

Scena contine obiectele jocului tău. Ale pot fi folosite pentru a crea meniul principal, nivele individuale, și restul de cerințe. Poți considera fiecare fișier scenă un nivel unic. În fiecare scenă, vei plasa mediul înconjurător, obstacolele, și decorațiuni, esențial desenând și construind jocul tău pe bucățele.

Figura 2.3 O scenă goală setată pe modul 3D

GameObject

Fiecare obiect din jocul tău este un GameObject. Totuși. GameObject-urile nu fac nimic de unele singure. Ele au nevoie de proprietăți speciale înainte de a deveni un personaj, un mediu, sau un efect special. Fiecare dintre aceste obiecte fac un lucru diferit. Dacă fiecare obiecte este un GameObject, cum putem diferenția un obiect de tip “power-up” (creștere putere) care este interctiv de o cameră statică? Ce face aceste obiecte diferite una de alta?

Figura 2.3.1 Diferite tipuri de obiecte GameObject

Răspunsul la această intrebare este că GameObjecturile sunt containere. Ele conțin diferite piese care sunt necesare pentru a face un caracter, un copac, o lumină, un sunet, sau orice ai vrea tu să construiești. Deci pentru a putea înțelege GameObjects, trebuie să înțelegi aceste piese care sunt numite Componente

În funcție de ce fel de obiecte vrei să creezi, va trebui să adaugi diferite combinații de Componente în Game Object. Consideră ca GameObject este o oală, și componentele sunt diferitele ingrediente care fac parte din rețeta ta de gameplay. Unity are de asemenea încorporat diferite tipuri de componente, și poti să-ți creezi propriile componente folosind scripturi.

O componentă principală este Transform (Transformare) care permite poziționarea, rotația și scala obiectului în joc sau scenă. Dacă GameObjectul nu ar fi avut componenta Transform, nu ar fi nimic decât niște informație în memoria calculatorului. Efectiv, nu ar exista în lume.

Figura 2.3.2 Fereastră de GameObject de bază

Tag – este folosit pentru a atribui un anumit numar unui obiect în așa încât va fi putea fi selectat direct împreună cu alte obiecte cu același tag.

Layer – pentru a nu suprapune mai multe obiecte unu peste altul, vor fi create layere pe care vom seta o parte din lume. Fiecare layer poate contine o un element din lume și poate fi folosit pentru a crea o categorie de obiecte.

Static – această casuță se bifeaza în cazul în care se dorește ca obiectul să fie static adică fără putea fi manipulat în joc.

Alte funcții secundare includ :

 Camera Component – Modificarea felului cum este prezentat obiectul în joc sau scenă.

 GUILayer – Straturi care includ anumite funcții interactive cum ar fi butoane sau mesaje text.

 Flare Layer – Implicit orice cameră are o strat flare care se poate traduce ca “efectul de soare”.

Audio Listener – Aplicarea de efecte sonore asura obiectului.

Figura 2.3.3 – Fereastră GameObject cu funcțiile secundare

Prefab

Este convenabil să construim un GameObject în scenă prin adăugarea de componente și setarea proprietăților lor la valori necesare. Asta poate crea probleme totusi, de exemplu când ai un obiect care e un personaj NPC, o mobila sau o bucată de scenă care este refolosită în scenă de catâva ori. Prin copiere, vom crea duplicate dar vor fi editabile independent. În general vrei ca toate instantele unui obiect în particular să aibe aceleași proprietăți, deci când editezi un obiect în scenă, ai prefer să nu trebuiască să faci aceleași editări repetate la fiecare copie.

Din fericire, Unity are un tip de asset numit Prefab care îți permite să stochezi un obiect GameObject complete cu componentele și proprietățile sale. Prefab-ul se comport ca un șablon din care poți crea noi instanțe de obiecte în scenă. Fiecare editare făcută la assetul de prefab sunt imediat aplicate în toate instanțele produse de ea dar se poate de asemenea să treacă peste componente și setări pentru fiecare instanță într-un mod individual.

Figura 2.3.4 Fereastră de creare a unui prefab

2.4 Input – Elemente de intrare

Unity suportă tipurile conveționale de dispozitive de intrare folosite în jocuri (tastatură, joypad etc.) dar de asemenea și ecrane tactile și detectoare de mișcare capabile pe dispozitive mobile. Aditional, Unity se poate folosi de microfonul calculatorului și camera wb pentru a da date de intrare de tip audi și video. Axele virtuale și butoanele pot fi create în Input Manager (Managerul de Date de Intrare), utilizatori avansați pot configura butoanele de tastaturat intr-o fereastră speciala de configurare care sunt folosite în jocuri moderne pentru a ușura modificarea butoanelor de control și acțiune totul printr-o simpla interfață de scripturi.

Axele Virtuale

De la scripturi, fiecare axă virtuala este accesată de la numele său. Fiecare proiect are următoarele axe implicite create de Unity.

Horizontal și Vertical care sunt mapate pe butoanele W,A,S,D și pe butoanele de sageți.

Fire1,Fire2,Fire3 (Foc1,2,3) sunt mapate pe butoanele Ctrl, Alt și Cmd, respectiv.

Mouse X și Mouse Y care sunt mapate pe mișcările delta ale mouselui

Window Shake X și Window Shake Y mapate pe mișcările ferestrei

Adăugarea de noi axe

Pentru adăugarea de noi axe, se poate folosi funcția specială din cadrul ferestrei de Input. Mapezi fiecare axă pe două butoane pe un joystick, mouse sau butoane de tastatură.

Figura 2.4 – Inspectorul, locul unde finguram axele

Name – Numele string-ului folosit pentru a verifica această axă de la un script.

Descriptive Name – Valuarea pozitivă aratată pe tab-ul de intrare în casuța de dialog “Configurration” pentru construcții proprii.

Descriptive Negative Name – Valuarea negativă aratată pe tab-ul de intrare în casuța de dialog “Configurration” pentru construcții proprii.

Negative Button – Butonul folosit pentru a împinge axa în direcția negativă.

Positive Button – Butonul folosit pentru a împinge axa în direcția pozitivă.

Alt Negative Button – Buton alternativ pentru a împinge axa în directia negativă.

Alt Positive Button – Buton alternativ pentru a împinge axa în direcția pozitiva.

Gravity – Viteza în unități pe secundă în care axa cade spre zona neutră atunci când nici un buton nu este apăsat.

Dead – Mărimea analogului din zona moartă. Toate valorile din dispozitivele analog care sunt în această rază rezultă o mapare neutră.

Sensitivity – Viteza în unități pe secundă în care axa va merge spre valoarea țintită. Acesta este doar pentru aparate digitale.

Snap – Dacă este bifat, valoarea axei se va reseta spre zero atunci când apăsăm un buton din direcția opusă.

Invert – Dacă este bifat, “Negative Buttons” vor oferi valori positive, și vice versa.

Type – Tipul de date de intrare care va controla axa.

Axis – Axa unui dizpozitiv conectat care va controla axa.

Joy Num – Joystickul conectat care va controla axa

De asemenea, se pot folosi scripturi pentru a seta stadiul curent al axei:

value = Input.GetAxis ("Horizontal");

O axă are o valorea intre -1 și 1. Poziția neutra este 0. Acest lucru se aplică pentru joystic și tastatură.

Totuși, delta mouse-ului și delta window shake-ului reprezintă cât de mult mouse-ul și fereastra s-a mișcat în ultimul cadru. Asta înseamnă că poate fi mai mare decât 1 și mai puțin decât -1 atunci cand utilizatorul mișcă mouse-ul rapid.

Este posibil să să creeze axe multiple cu același nume. Când luam datele de intrare ale axei, axa cu cea mai mare valoare absolută va fi returnată. Asta face posibilă setarea mai multor dispozitive pe un nume de axa pentru joystickul cu același nume. Dacă utilizatorul folosește joystick-ul, datele de intrare vor veni de la joystick, în caz contrar datele de intrare vor veni de la tastatura. În acest fel nu va trebui să consideri de unde vin datele de intrare atunci când scrii scripturi.

Numele butonelor

Pentru a mapa un buton la o axă, trebuie să introduci numele butonului în zona “Postivie Button” sau “Negative Button” în Inspector.

Numele butoanelor urmăresc următoarele convenții:

Taste normale: “a”, “b”, “c” …

Taste numerale: “1”, “2”, “3”, …

Taste sageti: “up”, “down”, “left”, “right”

Taste keypad: “[1]”, “[2]”, “[3]”, “[+]”, “[equals]”

Taste de modificare: “right shift”, “left shift”, “right ctrl”, “left ctrl”, “right alt”, “left alt”, “right cmd”, “left cmd”

Butoase mouse: “mouse 0”, “mouse 1”, “mouse 2”, …

Butonate joystick (de la orice joystick): “joystick button 0”, “joystick button 1”, “joystick button 2”, …

Butoane joystic (de la un joystick specific): “joystick 1 button 0”, “joystick 1 button 1”, “joystick 2 button 0”, …

Taste speciale: “backspace”, “tab”, “return”, “escape”, “space”, “delete”, “enter”, “insert”, “home”, “end”, “page up”, “page down”

Taste functionale: “f1”, “f2”, “f3”, …

Numele folosite pentru a identifica tastele sunt aceleași în interfata de scripting și în Inspector.

value = Input.GetKey ("a");

De reținut este faptul că cheile sunt accesibile folosind parametrul de enumrare KeyCode. Pe intrumente mobile, clasa Input oferă acces la ecranul tactic, accerometer și datele de intrare despre locația geografică.

În multe cazuri, Unity va prelucra singur datele de intrare ale tastaturii pentru elemente GUI dar este de asemenea simplu de arătat tastatura la cerere folosind un script.

Elemente GUI

Tastatura va apărea automat when un utilizator atinge un element GUI editabil. Folosind funcțiile GUI.TextField, GUI.TextArea și GUI.PasswordField, putem afișa pe ecran tastatura. Implicit, o căsută de editare va fi creată și plasată deasupra tastaturii după ce apare. Aceasta funcționează ca o previzualizare a textului a ce tasteaza utilizatorul. Totuși, este posibil ca această funcție să fie dezactivată modificând parametrii funcției. Este de notat faptul ca acest lucru funcționează doar pe anumite tipuri de tastaturi. De exemplu, nu va funcționa pe tastaturi de telefon și pe introducere de text cu multi-linii. În aceste cazuri, caseta de edit va apărea mereu.

2.5 Elemente RNG

Adăugarea de elemente de gameplay randomizate

Obiectele și valorile alege la întâmplare sunt importante în multe jocuri. În această secțiune vom arăta cum putem folosii funcțiile de randomizare integrate în Unity pentru a implementa niște mecanici de joc comune.

Alegerea unui obiect întâmplator dintr-un array

Pentru a alege un element array la întâmplare trebuie să ne conformăm la un număr intreg dintre 0 și maximum indexului ca valoare al array-ului. Asta poate fi realizat usor folosind funcția integrată Random.Range: –

var element = myArray[Random.Range(0, myArray.Length)];

Este de notat faptul că Random range întoarce o valoare care are o rază care include primul parametru dar îl exclude pe aldoilea, deci folosind myArray.Lenght aici ne va da rezultatul corect.

Alegerea obiectelor cu diferite posibiltăți

Câteodată, trebuie să alegi obiecte la întâmplare dar unele obiecte au șansa să fie alese mai des decât celelalte. De exemplu, un NPC – Non Playable Character , pracitc un personaj programat cu inteligență artificală poate reacționa în diferite cazuri atunci când întalneste un jucător:

50% șansă de a fi întâmpinat prietenește

25% șansă să fugă

20% șansă să atace imediat

5% șansă să ofere bani ca și cadou

Poți vizualiza diferitele urmări ca o foaie de hârtie divizată în secțiuni care reprezintă o ocupare a unei fracțiuni din totalul foii. Fracțiunea ocupată este egală cu probabilitatea ca acea urmare să fie aleasă. A face alegerea este echivalentul alegerii unui punt întâmplător de-a lungul lungimii foii (ca de exemplu, aruncarea unui săgeți) și apoi să observăm în ce secțiune este.

Figura 2.5 – Foaia de probabilitate

În script, foaia de hârtie este defapt un array de floats care conțin diferitele probabilități pentru obiect în ordine. Punctul întâmplător este obținut prin multiplicarea lui Random.value prin numărul total de floats din array. Pentru a afla care element dina array contine punctul “țintit” , trebuie să verificarm dacă nu cumva valoarea curentă este mai puțin decat în valoarea din primul element. Dacă e așa, atunci primul element este cel selectat. în caz contrar, se va substrage valoarea din primul elment după care se va compara cu al doilea element până când un element corect a fost găsit. în următorul cod, am implementat felul cum ar putea funcționa acest lucru într-un script.

// Javascript

function Choose(probs: float[]) {

var total = 0;

for (elem în probs) {

total += elem;}

var randomPoint = Random.value * total;

for (i = 0; i < probs.Length; i++) {

if (randomPoint < probs[i])

return i;

else

randomPoint -= probs[i]; }

return probs.Length – 1; }

//C#

float Choose (float[] probs) {

float total = 0;

foreach (float elem în probs) {

total += elem; }

float randomPoint = Random.value * total;

for (int i= 0; i < probs.Length; i++) {

if (randomPoint < probs[i]) {

return i; }

else {

randomPoint -= probs[i];

}

}

return probs.Length – 1;

}

Ultimul return este necesar deoarece Random.Value poate returna rezultatul 1. În acest caz, căutarea nu va găsii punctul întâmplator nicăeri. Dacă schimbam linia:

if (randomPoint &lt; probs[i])

… la un test cu valaore mai mică sau egal, ne va permite să scăpăm de afirmație dar va permite de asemenea unui obiect să fie ales ocazional chiar daca probabilitatea sa este zero.

2.6 Utilizarea luminior

Luminile sunt o parte esențială a oricărei scene. În timp ce plasele și texturile definesc forma și aspectul scenei, luminile definesc culoarea și atmosfera mediului tău 3D. Vei începe să lucrezi cu mai multe lumini în fiecare scenă cu cât prinzi mai multă experiență. Pentru a le face să funcționeze împreună necesită un pic de antrenament dar rezultatele pot fi chiar uimitoare.

Figura 2.6 O scenă cu doua setări de lumini

Luminile pot fi adăugate la scena ta direct la setările GameObject-ului. Poți alege formatul luminii care îl dorești din sub-meniul care va apărea. Imediat ce lumina a fost adăugată, o poți manipula ca orice GameObject. Adițional, poti adăuga o componentă de lumină pe orice GameObject selectat folosind funcția specifică din tabul Component.

Există multe opțiuni diferite în cadrul componentei de lumină din Inspector:

Figura 2.6.1 Lumini strălucitoare

Figura 2.6.2 Lumini întunecate medievale

Figura 2.6.3 Luminile nopții

Căi de rendare

Unity suportă diferite căi de rendare. Aceste căi afectează în principal luminile și umbrele, deci alegerea unui căi de rendare și în funcție de cererile jocului tău, poate îmbunătății performanța proiectului tău

2.7 Camera și manipularea ei

A scenă în Unity este creată prin aranjarea și mișcarea obiectelor într-un spațiu tri-dimensional. Pentru că ecranul celui care îl privește este bi-dimensional, trebuie să existe o cale de a captura o vedere și “storsă” pentru a fi afișată. Acest lucru se realizează folosind camerele.

O cameră este un obiect care definește o vedere într-un spațiu de scena. Poziția obiectului definește punctul de vedere, în timp ce axele „înainte” (Z) și „în sus” (Y) ale obiectului definesc direcția vederii și vârful ecranului, respectiv. Componenta camerei definește mărimea și forma regiunii care cade în vedere. Cu acești parametrii setați, camera poate afișa se poate “vedea” pe ecran. În timp ce obiectul cameră se mișcă și se rotește, vederea afișată se va mișca și rotii în consencință.

Camerele perspective și ortografice

O cameră în viața reala, sau chiar ochiul uman, vede lumea într-un mod care fac obiectele să pară mai mici cu cât sunt mai îndepărtate de la punctul de vedere. Acesastă bine cunoscut efect de perspectivă este des folosit în artă și în grafica pe calculator și este important în crearea unei scene realiste. Natural, Unity suportă camere perspective, dar pentru alte scopuri, trebuie să renduiesti această vedere fără acest efect. De exemplu, ai putea vrea să creezi o hartă sau un afisaj de informații care nu ar trebui să apară exact ca un obiect din viața reală. O cameră care nu diminuează mărimea obiectelor prin distanță este numită ortografic și camerele din Unity au de asemenea această opțiune. Modurile perspective și ortografice în a vizualiza o scenă se numesc “proiecții de cameră”.

Figura 2.7 În stânga este o cameră în perspectivă iar în dreapta o cameră în ortografic

Forma regiunii vizualizate

Ambele camere perspective și ortografice au o limită în cât de departe pot vedea de la poziția curentă. Această limită este definită de un plan care este perpendicular de direcția de înainte (Z) a camerei. Asta e cunoscută sub numele de “far clipping plane” (plan de tăiere îndepărtat) deoarece obiectele de la mare distanță sunt “tăiete” (excluse din rendering). Există de asemenea și “near clipping plane” (plan de tăiare apropriat) apropriat de camto top eră unde raza de vizualizare a distanței este între acele două plane.

Fără perspectivă, obiectele apar ca aceași mărime indiferent de distanță. Asta înseamnă că volumul de vizualizare a camerei ortografice este definită de o cutie dreptunghiulară care se extinde între cele două plane de tăiere.

Când perspectiva este folosită, obiectele apar să scadă în mărime în timp ce distanta de la cameră se măreste. Asta înseamnă că lățimea și înălțimea a părții vizualizate a scenei crește în timp ce crește distanța. Volumul de vedere a camerei perspective în acel caz nu mai este o cutie ci o piramidă cu vârful în poziția camerei și baza în planul de tăiere îndepărtat. Forma sa nu este tocmai o piramidă, dar totuși deoarece capul este tăiat datorită planului primește dunimirea de “trunchi” . Deoarece înălțimea nu este constantă, trunchiul este definit prin rata lățimei la înălțime care este cunoscut sub numele de “aspect ratio” (raport de aspect) iar unghiul dintre vârf și bază de la punctul maxim se numește „field of view”

Vederea camerei în fundal

Pentru scene care se întâmplă intr-o zonă închisă, camera poate fi complet înăuntru unui obiect care reprezintă interiorul clădirii, peșterii sau orice altă structura. Când acțiunea se petrece afară, vor exista multe zone dintre obiecte care vor fi umplute cu nimic. Aceste fundalui de obicei reprezintă cerul, spațiul sau scena unei ape tulburate în timp ce te scufunzi.

O camera nu poate părăsi fundalul complet nedecis așa ca trebuie să umple spațiul gol cu ceva. Cea mai simplă opțiune este să curețe fundalul spre o culoare plată înainte de renduiască scena deasupra ei. Poți seta această culoare folosind proprietatea Background ori în Inspector ori folosind un script. Un mod sofisticat de a rezolva asta și care funcționează bine cu scene din afară este să folosim un Skybox (Cutie de cer). Așa cum numele sugerează, un skybox se comportă ca o “cutie” liniată cu imagini ale cerului. Camera este efectiv plasată în centrul acestei cutii (în așa fel încât camera nu se poate apropria de cer). Skybox-ul este renduit în spatele obiectelor în cadrul scenei în așa fel încât este reprezentat ca o vedere cu distanță infinită. Cea mai des utilizată medota este să reprezinte cerul intr-o scenă plasată afară, trucul fiind că skybox-ul acoperă totul, chiar și dedesuptul scenei. Asta înseamnă că poți folosii un skybox să reprezinți parți ale scenei (exemplu: câmpuri extinse care se întind dincolo de orizont) sau o vedere de 360 de grade a unei scene în spațiu sau sub apă.

Un skybox poate fi adăugat ușor doar selectând în fereastra de instumente ale Lightning (Lumină).

2.8 Unity în 2D

Figura 2.8 Jocuri freeware create în 2D

Chiar dacă Unity este faimos pentru capabilitățile sale 3D, poate fi folosit de asemenea să creăm jocuri 2D. Funcțiile familiare ale editorului sunt încă valabile dar cu adițiuni ajutătoare care simplifică dezvoltarea 2D.

Cea mai observabilă funcționalitate este butonul modul de vedere 2D care se află în bara de instrumente a vederii scenei. Când modul 2D este activat, o vedere ortografică va fi setatăș camera se va uita pe axa Z iar axa Y se va duce în sus. Asta îți permite să vizualizezi scena și să plasezi obiecte 2D ușor.

Figura 2.8.1 Scena unui joc 2D

Grafica 2D

Obiectele grafice în 2D sunt cunoscute sub numele de Sprite-uri. Sprite-urile sunt în esență doar texturi standarde dar cu tehnici speciale pentru combinarea și administrarea texturilor cu eficiență și convenabilitate în timpul dezvoltării. Unity are integrat un Editor de Sprite-uri care îți permite să extragi sprite-uri grafice de la o poză mai mare. Acest lucru îți mai permite să editezi și un număr de imagini compoente în cadrul unei singure texturi în editorul tău de imagini. Poți folosi asta de exemplu atunci cand vrei să păstrezi mâinile, picioarele și corpul unui personaj ca elemente separate intr-o singura poză.

Sprite-urile sunt renduite cu o componentă “Sprite Renderer” (Render de Sprite-uri) în locul lui Mesh Renderer (Render de plase) folosit în obiecte 3D. Poți adăuga acest lucru la un GameObject în cadrul meniului de Componente sau alternative, poți crea un GameObject direct atașat cu Sprite Renderer de el.

În plus, poți folosi “Sprite Creator” (Creatorul de Sprite-uri) pentru a crea imagini 2D înlocuibile

Figura 2.8.2 Inspectorul pentru Sprite-uri

Fizica 2D

Unity trebuie să separe motorul de legi ale fizicii pentru a putea rula fizică 2D și să creeze optimizări valabile doar în 2D. Componentele care corespund fizicii 3D sunt alterate în așa fel încat să fie folosite în mediul 2D. Acestea sunt :

Rigidbody 2D – care plaseaza obiectul sub control motorului de legi ale naturii

Box Collider 2D – care setează materialul obiectului și dacă are puterea să interacționeze cu obiectele din jur.

Hinge Joint 2D – care face posibilă alterarea spațiului atunci cand obiectul este de exemplu atins

Constant Force 2D

Area Effector 2D

Buoyancy Effector 2D

Point Effector 2D

Platform Effector 2D

Surface Effector 2D

2.9 Elemente de legi de fizică

Pentru a avea un comportament fizic convingător, un obiect într-un joc trebuie să accelereze corect și să fie afectat de coliziuni, gravitație și alte forțe. Motorul încorporat de legi de fizică în Unity oferă componente care se ocupă cu simularea fizică pentru tine. Cu doar câteva setări parametrii, poți crae obiecte care se comportă pasic într-un mod realistic (exemplu: vor fi mișcate de coliziuni sau căderi dar nu vor începe să se miște singure). Prin controlul fizicii prin scripturi, poți da obiectului dinamica unui vehicul, o mașinărie sau chiar o bucată de panză mișcătoare. În următoare secțiune voi enumera și clasifica componentele folosite în aplicarea legilor de fizică.

Rigidbodies (Corp rigid)

Un Rigidbody este componenta principală care permite comportament fizic asupra unui obiect. Când un Rigidbody este atașat, obiectul va răspunde imediat gravitației. Dacă unul sau mai multe componente Colider (Detector de Coleziune) sunt adăugate, atunci obiectul va fi mișcat de viitoarele coleziuni.

Pentru că o componentă Rigidbody preia controlul asupra miscărilor obiectului de care este atașat, nu ar trebui să încerci să îl miști dintr-un script prin modificarea proprietăților din Transform ca de exemplu poziție și rotație. În loc, ar trebui să aplici forțe care vor împinge obiectul și să lase motorul de legi de fizică să calculeze rezultatele.

Există cazuri când vrei ca un obiect să aibă Rigidbody fără a fi controlat de către motorul de legi de fizică. Exemplu, ai putea vrea să-ți controlezi personajul direct dintr-un cod script dar să-i lași permisiunea să fie detectat de triggers (trăgaci). Acest tip de moțiune produsă de la un script, se numeste moțiune kinematică. Componenta Rigidbody are o proprietate numită “Is Kinematic” care va scoate controlul motorului de legi de ficică și sa-i permită să fie mișcat kinematic de la un script care va permite fizicii să fie oprită sau pornită pentru obiect, dar asta vine cu un cost de performanță și trebuie folosit rareori.

Colliders (Detector de coleziune)

Componentele de coleziune definesc forma obiectului pentru scopul coliziunii fizice. Un detector de coleziune, care este invizibil, nu trebuie să aibă aceasi forma ca și plasa obiectului și este defapt o aproximare rigidă care este de obicei mult mai eficientă și imperceptibil în gameplay.

Cu poziționări și redimensionări precise, detectorii de coliziune compuse pot des să aproximeze forma unui obiect chiar foarte bine în timp ce păstreaza consumul procesorului la minim. În continuare, mai multă flexibilitate poate fi obținută prin adăugarea de detectoare de coleziune adiționale asupra unor obiecte tinere. Când creăm un astfel de combos, ar trebui să fie o singură componentă RigidBody plasată pe rădăcina obiectului din ierarhie.

Detectoarele de coleziune primitive nu vor funcționa corect pe transformări bifurcate, acest lucru însemnând că dacă folosesti o combinație de rotații și scalări non-unifrome în ierarhia de transformări, astfel încât că forma rezultată nu se va mai potrivii cu forma primitivă iar în final detectorul de colieziune primitiv nu va putea să-l reprezinte corect.

Physics materials (Materiale fizice)

Când detectoarele de coleziune interacționează, suprafețele lor trebuie să simuleze proprietățile materialului pe care trebuie să-l reprezinte. De exemplu, o strat de gheață o să fie alunecos în timp ce o minge de cauciuc va oferii multă fricțiune și sărituri care pot fi configurate folosind Physics Materials. Obținerea parametrilor potriviți necesită câteva incercări dar un material de gheată de exemplu va avea zero (sau foarte puțină) fricțoune iar materiaul de cauciuc va avea fricțiune mare și va putea sării în sus aproape perfect.

Triggers (Tragăci)

Sistemul de scripting poate detecta când se întâmplă coleziunile și să inițieze acțiuni folosind funcția OnCollisionEnter. Totusi, poți folosii motorul de legi de fizică doar pentru simplul fapt să detecteze când un detector de coleziune intră în spațiul altuia fără a creea o coleziune. Un detector de coleziune configurat ca un Trigger (folosind proprietatea Is Trigger) nu se comportă ca un obiect solid și va permite celorlalte obiecte să treacă prin el. Când un detector de coleziune intră în spațiul său, un trigger va apela funcția OnTriggerEnter asupra scriptului obiectului.

Acțiunele scriptului luate asupra coleziuni

Când coleziunile se întâmplă, motorul de legi de fizică apelează funcții cu nume specifice asupra oricărui script atașat pe obiectele propriu-zise. Poți plasa orice fel de cod vrei în aceste funcții ca să răspundă evenimentului de coleziuni. De exemplu, ai putea rula un sunet de izbire atunci când o măsină lovește un obstacol.

Interacțiunile cu detectorul de coleziune

Detectoarele interacționeaza diferit unul cu altul depinzând la cum sunt configurate componetele Rigidbody. Cele trei configuratii importante sunt:

Static Collider (Detector de coleziune static) – acesta este un GameObject care are un detector de coleziune dar nici un Rigidbody. Detectoarele statice sunt folosite pentru geometrie nivelată care mereu stă în acelasi loc și nu se miscă niciodată. Obiectele rigdbody care se izbesc de el, vor creea o coleziune cu detectorul static dar nu îl va mișca.

Rigidbody Collider (Detector de coleziune la corpuri rigide) – acesta este un game un GameObject cu un detector de coleziune și un ridigbody normal, non-kinematic. Detectoarele rigidbody sunt simulate pe deplin de către motorul de legi de fizică și poate reacționa la coleziuni și forțe aplicate de la un script. Pot face coleziune cu alte obiecte (incluzând detectoarele statice) și este cel mai folosită configurare de detector de coleziune în jocuri care folosesc legile fizicii.

Kinematic Rigidbody Collider – acesta este un GameOBject cu un detector de coleziune și un Rigidbody cu proprietatea IsKenatic aplicată asupra lui. Ele se folosesc pentru detectoare care pot fi mișcate sau pornite/oprite ocazional dar în rest să se comporte ca niște detectoare statice. Un exemplu ar fi o usă automată care se deschide doar când este necesar dar în rest este un obiect care nu poate să se miște.

Joint (Îmbinări)

Poți atașa un corp rigidbody pe altul sau într-un punct fix în spațiu folosind componenta Joint. în general, vrei ca un joint să permită cel puțin niște libertate de mișcare așa ca Unity oferă diferite componente Joint care aplică diverse restricții :

Hinge Joint (Balama) permite rotația în jurul unui punct specfic sau pe axă.

Spring Joint (Arc) păstrează obiectele separate dar lasă disntața dintre ele să se întindă un pic.

Joint-urile au și alte opțiuni care pot fi pornite pentru efecte specifice. De exemplu, poți seta ca un joint să se rupa atunci când forța care este aplicata asupra sa trece peste o valoare setatp. Unele joint-uri permite un drive force (unitate forte) să apară între obiectele conectate pentru a le seta în moțiune automat.

Character Controllers (Controlor caracter)

Personajul într-un joc care e la prima sau a treia persoană va avea nevoie des de niște fizică de coleziune în așa fel încât personajul nu cade prin podea sau să meargă prin pereți. De obicei, accelerația personajului și miscările nu vor fi realistic fizic, deci va putea să accereze, frâneze și să-și schimbe direcția fără să fie afectat de impuls.

În fizica 3D, acest tip de comportament poate fi creat folosind Character Controller. Această componenta îi dă personajului un simplu detector de coleziune în formă de cilindru care este mereu ridicat. Controlorul are propria funcție specială de a seta viteza și direcția dar în comparație cu detectoarele adevărate, un rigidbody nu este necesar iar efectele impuls nu sunt realiste.

Un controlor de caracter nu poate merge prin detectoare statice într-o scenă, așa că va urmării etajele și va fi obstrucționat de pereți. Poate împinge obiecte rigidbody în timp ce se miscă dar nu poate fi accelerat de coleziuni care se aproprie. Asta înseamnă ca poți folosii detectoarele 3D standard să creezi o scenă în jur în care controlorul va merge dar nu ești limitat de comportament fizic realistic asupra personajului însuși.

2.10 Scripturile în Unity

Scriptingul este un ingredient esențial în toate jocurile. Chiar și cel mai simplu joc va avea nevoie de scripturi pentru a răspunde la datele de la jucator și să aranjeze evenimentele în gameplay care urmează să se întâmple să fie realizate la timp. Înafară de asta, scripturile pot fi folosite pentru a crea efecte grafice, controlarea comportamentului fizic al obiectelor și chiar să implementezi inteligență arfiticială customizată pentru personajele din joc.

Scriptingul este o abilitate care necesită timp și efort pentru a fi învățat; intenția acestei secții nu este cum să scrii code script de la 0 ci să explicăm conceptele principale care se aplică

în scripting pentru Unity.

Chiar dacă Unity folosește o implementare al standardului Mono rulant pentru scripting, acesta încă are propria practică și tehnici pentru a accesa motorul din scripturi. Acestă secțiune explică cum sunt obiectele create în editorul Unity controlate prin scripturi, și detalii despre relația dintre funcționalitățile de gameplay din Unity și Mono.

Comportamentul GameObjecturilor este controlat de către compoentele care sunt atașate de ele. Chiar dacă componentele integrate în Unity sunt foarte versatile, vei afla în curand că va trebui să depăsesti limita pe care ți le dă pentru a implementa propriile tale funcționalități. Unity îți permite să-ți creezi propriile Componente folosind scripturile. Acestea ajut la începerea sau tragerea de evenimente din joc, și de asemena modificările Componentului se vor reflecta pe ecran în orice fel dorești.

Unity suporta doua limbaje de programare native:

C#- un limbaj standard industrial similar cu Java sau C++

UnityScript – un limbaj creat special pentru folosirea cu Unity și modelat dupa JavaScript

În plus de acestea, multe alte limbi .NET pot fi folosite cu Unity daca pot să compileze un DLL compatibil.

Crearea de scripturi

Spre deosebire de assets, scripturile sunt create în cadrul programului Unity direct. Poți crea un no script direct din meniul Create în secțiunea Project.

Noul script va fi creat în oricare folder ai ales să fie selectat în panoul Project. Numele nou al fișierului va fi selectat, oferindu-ti obținuea de ai da un nume nou.

Anatomia unui fișier script

Când dai dublu-click pe un asset în Unity, el va deschis într-un editor text. Implicit, Unity va folosii MonoDevelop, dar poti selecta orice editor vrei din panoul Externomal Tools în preferințele lui Unity.

Principalul continue al fișierului script creat chiar acum este:

using UnityEngine;

using System.Collections;

public class MainPlayer : MonoBehaviour {

// Folosește aceata pentru initializare

void Start () { }

// Un update este apelat per frame

void Update () { }

}

Un script face conexiunea cu lucrul inteterior al lui Unity prim implementarea unui clase care deriveaza de la o clasa integrată numit MonoBevaviour. Numele clasei este acelasi cu numele fisierului creat.

Cele doua funcții sunt definite în clasa și au următoarele funcționaleȘ

Update (Actualizare) – funcția unde se pune codul care va avea grijă de actualizarea per tablou al GameObjectului. Asta ar putea include miscări, declanșarea unor acțiuni.

Start – este apelată de Unity înainte ca gameplay-ul să înceapă prin introducerea de variabilele alea

Un UnityScript script funcționează puțin diferit în C# Ș

#pragma strict

function Start () {

}

function Update () {

}

Aici, funcțiile de Start și Update au aceași întelegere dar clasa nu este declarată explicată.

Controlarea unui GameObject

Așa cum am notat mai sus, un script doar defintește un plan pentru o Componentă și nici-o linie de cod nu vor fi activata până când o instanță a scriptului este atașat de GameOBject. Poți atașa un script trăgand assetul într-un GameObject. Acest lucru este de asemenea folosit și un submeniu de scripturi aflate în cadrul meniului Component care arată fiecare script aflat în proiect incluzând și pe tine. Instanța de script arată ca orice altă componenta în Inspector:

Figura 2.10 O fereastră în GamObject și includerea de scripturi

De îndată atașat, scriptul va funcționa când apeși Play și rulezi jocul. Poți verifica acest lucru prin adăugarea următorului cod în funcția Start:

// Foloseste acest cod pentru inițializare

void Start () {

Debug.Log("Sunt viu!");}

Debug.Log este o comandă simplă care doar printează un mesaj în datele de ieșire a consolei Unity. Dacă apăsam Play acum, o să vezi mesajul la baza editorului Unity și în fereastra Consolei

Variabilele și Inspectorul

Când creezi un script, tu în esență creezi propriul tău component nou nouț care poate fi atașat pe GameObjects la fel ca orice altă componentă.

La fel cum celelalte componente au multe proprietăți care sunt editabile în Inspector, poți permite valori în scriptul să fie de către Inspector de asemenea

using UnityEngine;

using System.Collections;

public class MainPlayer : MonoBehaviour {

public string myName;

// Foloseste acest cod pentru inițializare

void Start () {

Debug.Log("Sunt viu și numele meu este…" + myName);

}

// Update este apelat dupa fiecare cadru.

void Update () {

}

}

Acest cod creează o zonă editabilă în Inspector numit “My name”

Figura 2.10 Fereasta cu inspectorul current

Unity creează numele Inspectorului prin introducerea unui spațiu de fiecare dată când o literă mare apare în numele variabilei. Totuși, aceste este doar pur pentru scop de design și ar trebui să folosești mereu numele variabilei în codul tău. Dacă editezi numele și apoi apeși Play, vei vedea acel mesaj care include textul care l-ai introdus

Figura 2.10.1 Numele variabilei afișat

În C#, trebuie să declari o variabila ca public pentru a putea fi văzută în Inspector. În Unity Script, variabilele sunt public în mod implicit doar dacă nu cumva specifici ca sunt private:

#pragma strict

private var invisibleVar: int;

function Start () {}

Unity te va lăsa să schimbi valorea variabilelor din scripturi în timp ce jocul ruleaza. Acest lucru este folositor pentru a vedea schimbările în efecte direct fără a opri jocul și apoi să-l repornești. Când gameplay-ul este încheiat, valorile variabilelor vor fi resetate spre oricât au fost înainte să apeși Play. Asta asigură că ești liber să-ti modifici setările obiectului fără frica de face daune permanente.

Controlul GameObjecturilor folosind componente

În editorul Unity, poți face modificări la proprietățile Componentelor folosind Inspectorul. Deci, de exemplu, modificări la valorile pozițiile a componentei Transform va rezulta într-o schimbare în pozitia GameObject-ului. Similar, poți schimba culoarea materialului unui render sau masa unui Rigidbody cu un efect corespunzător asupra aspectului sau al comportamentului GameObject-ului. Pentru marea parte, scriptingul este de asemenea folosit și pentru modificarea proprietăților Componentei pentru a manipula GameObject-uri. Diferența fiind că un script poate diversifica valoarea proprietății gradual sau în răspuns de la datele de intratre introduse de utilizator. Prin schimbare, creare și distrugerea obiectelor la timpul potrivit, un nou tip de gameplay poate fi implementat.

Accesarea Componentelor

Cel mai simplu caz este atunci cand scriptul are nevoie de accces la celelalte Componente atașate de același GameObject. Cum am menționat în introducerea subcapitolului, o Componentă este defapt o instanță a unei clase deci primul pas este să luam o referință către instanța Componentei cu care vrei să lucrezi. Asta se realizează cu ajutorul funcției GetComponent. Tipic, vei vrea să atribui objectului Component pe o variabilă, care este realizat în C# folosind urmatoarea syntaxă:

void Start () {

Rigidbody rb = GetComponent<Rigidbody>();

}

În UnityScript, sintaxa este diferită subtil :

function Start () {

var rb = GetComponent.<Rigidbody>();

}

Imediat ce ai o referință spre o instanța unui Componente, poți seta valorile proprietăților la fel de mult cum o poți face în Inspector :

void Start () {

Rigidbody rb = GetComponent<Rigidbody>();

//Schimbă masa unui obiect Rigidbody.

rb.mass = 10f;

}

O funcționalitate extra care nu se află în Inspector este posibilitatea apelării funcțiilor pe instanțele Componentelor :

void Start () {

Rigidbody rb = GetComponent<Rigidbody>();

// Adaugă o forță la Rigidbody.

rb.AddForce(Vector3.up * 10f);

}

Nu există nici un motiv să nu ai mai mult de un script custom atașat la același obiect. Dacă vrei să accesezi un script pe rând, poți folosi funcția GetComponent și doar introduci numele clasei de script (sau a fisierului) pentru a specifica tipul Componentei dorite.

Dacă încerci să recuperezi o Componentă care nu a fost adăugată la GameObject, atunci GetComponent va returna null; vei primi o eroare de referință null la lansare dacă încerci să schimbi valorile la un obiect null.

Accesarea altor obiecte

Cu toate că ele operează în izolație, este comun pentru scripturi să țină seamă altor obiecte. De exemplu, un inamic care te urmărește ar trebui să știe poziția jucătorului. Unity ofera un număr diferit de căi în a recupera alte obiecte, fiecare corespunzator la anumite situații.

Legarea obiectelor cu variabile

Cel mai scurt și concis mod de a gasi un GameObject anume este să adăugam un o variabilă public GameObject direct la script:

public class Enemy : MonoBehaviour {

public GameObject player;

// Alte variabile și funcții…}

Variabila va fi vizibilă în Inspector ca oricare din ele:

Figura 2.10.2 Scriptul unui inamic

Acum poți trage un obiect din scenă sau din panoul de Ierahie în această variabilă pentru a o atribui. Funcția GetComponent și variabilele de acces a Componetei sunt disponibile pentru acest obiect la fel ca oricare altul, deci poți folosi codul următor :

public class Enemy : MonoBehaviour {

public GameObject player;

void Start() {

// Fă inamicul să apară 10 unități în spatele jucătorului

transform.position = player.transform.position – Vector3.forward * 10f; }

}

Adițional, dacă declare o variabilă public a unui tip de Component în scriptul tau, poți trage orice GameObject care are o component atașată de ea. Asta va accesa Componenta direct în loc să acceseze GameObjectul însuși.

public Transform playerTransform;

Legarea obiectelor împreună cu variabile este cel mai folositor atunci când lucrăm cu obiecte individuale care au conexiune permanente. Poți folosi o variabila array pentru a lega maimulte obiecte de același tip, dar conexiunile tot trebuiesc făcute în editorul Unity decât să o faci în lansare. Este des convenabil să localizezi obiecte în timpul rularii iar Unity va oferi două căi de a face asta, așa cum voi descrie mai jos.

Găsirea obiectelor copil (tinere)

Câteodată, o scenă de joc se va folosi de un număr de obiecte de același tip, ca de exemplu inamicii, puncte de căi și obstacole. Acestea vor trebuie să fie urmărite de un script particular care supervizează sau reacționează cu ele (exemplu, toate punctele de căi vor trebuie să fie disponibile scriptului de pathfinding (găsire cale)). Folosind variabilele pentru a lega aceste obiecte este o posibilitate dar va face procesul de design o muncă grea dacă fiecare punct de cale a fost tras spre o variabilă pe un script. De asemenea, dacă un punct de cale este șters atunci va fi o muncă în plus să ștergem variabilele referință la un obiect lipsa. În cazuri ca acestea, este mai bine să administrăm un set de obiecte făcându-le pe toate copii al unui obiect părinte. Obiectele copil pot fi returnate folosind Componenta Transform a părintelui (deoarece toate GameObjects au implicit un Transform)

using UnityEngine;

public class WaypointManager : MonoBehaviour {

public Transform[] waypoints;

void Start() {

waypoints = new Transform[transform.childCount];

int i = 0;

foreach (Transform t în transform) {

waypoints[i++] = t;

}

}

}

Poți de asemenea să localizezi un obiect copil specific folosind funcția Transform.Find:

transform.Find("Gun");

Asta poate fi folositor când un obiect are un copil care poate fi adăugat sau scos în timpul gameplay-ului. O armă care poate fi luată de pe jos și aruncată iar este un bun exemplu în această situație.

Găsirea obiectelor prin Nume sau Tag

Mereua fost posibil să localizezi GameObjects oriunde în ierahhia scenei atâta timp cât ai niște în informație că le poți identifica.

Obiectele individuale pot fi recuperate prin nume folsind funcția GameObject.Find:

GameObject player;

void Start() {

player = GameObject.Find("MainHeroCharacter");

}

Un obiect sau o colectie de obiecte pot fi de asemenea localizate prin tag-ul lor folosing funcțiile GameObject.FindWithTag și GameObject.FindGameObjectWithTag.

GameObject player;

GameObject[] enemies;

void Start() {

player = GameObject.FindWithTag("Player");

enemies = GameObject.FindGameObjectsWithTag("Enemy");

}

Funcțiile eveniment

Un script în Unity nu este ca o idee tradițională a unui program unde codul ruleaza în continui într-o buclă până când își termină sarcina. În schimb, Unity paseaza controlul la un script intermident prin apelarea unor anumite funcții care sunt declarate în el. De îndată ce funcția și-a terminat execuți, controlul este pasat înapoi la Unity. Aceste fucții sunt cunoscute sub numele de funcții eveniment deoarece sunt activate de Unity în consencința evenimentelor care se întâmplă în timpul gameplay-ului. Unity folosește o schemă de numire pentru a identifica care funcție să o apeleze pentru un anumit eveniment. De exemplu, deja ai văzut funcțiile de Update (apelată înaintea actualizării primului cadru al obiectului) și de Start (apelată chiar înaintea actualizării primului cadru al obiectului). Multe funcții de eveniment sunt disponibile în Unity, următoarele sunt cele mai comune și cele mai importante.

Evenimente actualizate regular

Un joc mai degrabă ca o animație unde cadrele animației sunt generate pe loc. Un concept cheie în programarea jocurilor este rendarea fiecărui cadru se face imediat ce obiectul își schimbă poziția, stadiul și comportamentul. Funcția de Update este locul principal pentru acest tip de cod în Unity. Update este apelat înainte de-a fi renduit cadrul și de asemenea înainte ca animațiile să fie calculate.

void Update() {

float distance = speed * Time.deltaTime * Input.GetAxis("Horizontal");

transform.Translate(Vector3.right * distance);

}

Motorul de legi de fizică actualizează de asemenea în timp discret toți pașii într-un mod similar la renduirea cadrului. O funcție eveniment separată numită FixedUpdate este apelată chiar înaintea actualizării fiecărui eveniment fizic. Deoarece actualizările fizice și actualizările de cadru nu apar cu aceași frecvență, vei primi rezultate cu o acuratețe mai mare de la un cod fizic dacă îl plasezi în funcția FixedUpdate decât în cel de Update.

void FixedUpdate() {

Vector3 force = transform.forward * driveForce * Input.GetAxis("Vertical");

rigidbody.AddForce(force);

}

Este de asemenea folositor câteodata să faci modificări adiționale într-un punct după cefuncțiile Update și FixedUpdate au fost apelate pentru toate obiectele din scenă și dupa ce toate animațiile au fost calculate. Un alt exemple este atunci când codul scriptului ar trebui să înlocuiască efectul unei animații (să zicem, să facem capul personajului să se uite către obiectul țintit din scenă). Funcția LateUpdate poate fi folosită pentru aceste situații.

void LateUpdate() {

Camera.main.transform.LookAt(target.transform);

}

Evenimente de Inițializare

Este des folositor să putem să apelam codul de inițializare mai înaintea oricărei actualizări care se întamplă în timpul gameplay-ului. Funcția Start este apelată chiar înaintea primul cadru sau actulizare fizică asupra unuo obiect. Functia Awake este apelată pentru fiecare obiect din scenă atunci când scena se încarcă. Chiar dacă sunt anumite Obiecte, funcțiile Start și Awake sunt apelate într-un ordin arbitrar, toate Awake-urile vor fi terminat înaintea ca Start să fie pentru prima dată apelat. Asta înseamnă că codul într-o funcție Start se poate folosi de alte inițializări făcute anterior în faza Awake.

Evenimente GUI

Unity are un sistem de rendare a controarelor GUI asura unei acțiuni principale din scenă și corespunde la click-uri la aceste controale. Codul este mânuit puțin diferit față de actualizarea normală a cadrului și așa că trebuie plasat într-o funcție OnGUI, care va fi apelată periodic.

void OnGUI() {

GUI.Label(labelRect, "Game Over");

}

Poti de asemenea detecta evenimente ale mouse-ului care se întâmplă pe parcusul unui obiect GameObject așa cum apare în scenă. Asta poate fi folosit pentru arme cu țintă sau pentru afișarea de informații despre caracterul pe care se ține cursorul mouse-ului. Un set de functii eveniment OnMouseXXX (exemplu, OnMouseOver, OnMouseDown) sunt disponibile care permit unui script să reacționeze la acțiunile utilizatorului folosind mouse-ul. De exemplu, dacă butonul unui mouse este apăsat în timp ce cursorul este deasupra unui obiect particular atunci o funcție OnMouseDown în scriptul acelui obiect va fi apelată dacă există.

Evenimente fizice

Motorul de legi de fizică va raporta coleziuni asupra unui obiect prin apelarea unor funcții eveniment în scriptul acelui obiect. Funcțiile OnCollisionEnter, OnCollisionStay și OnCollisionExit vor fi apelate în timp ce contactul se realizează, susține sau sparge. Funcțiile acestea vor fi apeleate când detectorul de coleziune al obiectului este configurat ca un Triger (adică un detector care doar simte când ceva intră în el în loc să reacționeze fizic). Aceste funcții vor fi apelate de cateva ori în succesiune dacă mai multe contacte au fost detectate în timpul actualizării fizice și așa că un parametru este pasat spre funcție care dă detalii despre coleziune (pozitie, identitatea obiectului care se aproprie, etc.)

void OnCollisionEnter(otherObj: Collision) {

if (otherObj.tag == "Arrow") {

ApplyDamage(10); }}

Clase Importante

Acestea sunt cele mai importante clase pe care le vei folosii atunci faci scripturi în Unity. Ele acopera nișste zone de bază a sistemelui de script al lui Unity și ofera un punct de start pun pentru a vedea ce funcții și evenimente sunt disponibile

MonoBehaviour – Clasa de bază pentru toate scripturile Unity, referința MonoBehaviour îți ofera o lista cu toate funcțiile și evenimentele care sunt disponibile în scripturi standarde atașsate de obiecte de joc.

Transform – Fiecare obiect de joc care o poziție, rotație și o scală în spațiu (fie el 3D sau 2D), și aste reprezentat prin componenta Transform. În timp ce oferă această informație, componenta transform are multe funcții ajutătoare care pot fi folosite să mișcam, scalăm, rotii, recurențăm și manipulăm obiecte. De asemenea putem convertii coordonate de la un spațiu la altul.

2.11 Rețea cu mai mulți jucători (Multiplayer)

Prezentare generală

Exită doua timpuri de utilizatori care folosesc funcționalitatea de lucru în rețea:

Utilizatori care fac un joc Multiplayer cu Unity. Acesti utilizatori ar trebui să înceapă să folosească NetworkManager sau High Level API

Utilizaotir care doresc să construiască o infrastructură de rețea sau jocuri avansate de multiplayer. Acest utilizatori ar trebui să înceapă cu NetworkTransport API

High level scripting API

Rețeaua lui Unity conține un script API de “nivel-înalt” (care se prescurtează HLAPI). Fosind acesta înseamnă că ai acces la comenzi care acoperă aproape toate cererile necesare pentru un joc utilizat de mai mulți jucatori făra să te îngrijorezi de “nivelul inferior al detaliilor de implementare. HLAPI îți permite să :

Controlezi stadiul rețelui jocului folosind un “Network Manager”.

Să operezi jocuri găzduite de clienți, unde gaza este de asemenea un jucător client.

Să serialezi date folosind un serializator standard făcut pentru acest scop.

Să trimiți și să primești mesaje în rețea.

Să trimiți comenzi de rețea de la clienți la servere.

Să efectuezi apelari procedurale de la distanță de la servere la clienți.

Să trimiți evenimente de rețea de la servere la clienți.

Integrarea motorului și al editorului

Rețeaua lui Unity este integrată în motorul graphic și în editor, permitandu-ți să lucrezi cu componente și ajutor vizual pentru a-ți construii jocul multiplaer. Oferă:

O componentă NetworkIdentity pentru obiecte de rețea.

O componentă NetworkBehaviour pentru scripturi de rețtea.

Configurare sincronizată și automată a transformării obiectelor.

Sincronizare automată a variabilelor de script.

Suport pentru plasarea de obiecte de rețea în scenele Unity.

Componente de rețea.

Servicii de internet

Unity ofera servicii de internet pentru a suporta jocul tăi pe parcusul producției și lansării, asta include:

Serviciu Matchmaking (creare meci).

Crearea de meciuri și meciuri de publicitate.

Lista cu meciurile disponibile și meciurile în care te poți alătura.

Un server relay (releu).

Game-play pe internet fără server dedicat.

Rutare a mesajelor pentru participanții meciurilor.

Straturi de transport în timp real folosind NetworkTransport

Unity include un Real-Time Transport Layer care oferă:

Protocol bazat pe UDP optimizat.

Design multi-canal făcut pentru a evita probleme de blocare.

Suport pentru o varietate de nivele de “Serviciu de calitate” per canal.

Topologie flexibilă a rețelei care suportă arhitecturile peer-to-peer sau client-server.

2.12 Sunetele în Unity

Audio-ul în Unity are ca funcționaltăți full 3D sunet spațial, mixing în timp real și masterare, ierarhiile de mixeri, snapshots (instantanee), efecte predefinite și tot mai multe.

Prezentare generală

Un joc ar fi imcomplet fară un tip de audio, fie el muzică de fundal sau efecte de sunete. Sistemul audio al lui Unity este flexibil și puternic. Poate să importe multe formate audio standarde și are funcționalități sofisticate pentru a reda sunete într-un spatiu 3D, opțional cu efecte ca ecou și filtrare aplicate. Unity poate de asemenea să înregistreze audio de la orice microfon valabil în dispozitivul utilizatorului pentru folosirea lui în timpul gameplay-ului sau pentru stocare și transmisie.

Teorie de bază

În viața reală, sunetele sunt emise de obiecte și auzite de ascultători. Modul cum sunetul este perceptat depinde de un număr de factori. Un ascultător poate spune din ce direcție vine sunetul și poate să-și dea seama de distanța sa bazat pe cât de tare e și de calitate. O sursă de sunet rapid și mișcător (exemplu, o bombă care cade sau o mașină de poliție care trece pe lânga time) se va schimba în pas în timp ce se misca că rezultat al efectului Doppler. De asemenea, împrejurimile vor afecta calea cum sunetul este reflectat, deci o voce care se aude din interioul unei peșteri va avea un ecou dar aceași voce făcută afară nu va avea.

Figura 2.12 Sursele audio și ascultătorul

Pentru a simula efectele poziției, Unity necesită sunete care au originea în Surse Audio atașate de obiecte. După ce emițătorul de sunete este luat de un Ascultător Audi atașat altui obiect care este de obicei în camera principală. Unity poate atunci să simuleze efectele sunetului ca de exemplu disntanța și poziția de la obiectul ascultătorului și să le redeze la utilizator cum trebuie. Viteza relativă a obiectelor sursei și ascultătorului pot fi folosite de asemenea pentru a simula efectul Doppler pentru mai mult realism.

Unity nu poate calcula ecouri direct din geometria scenei dar poți să le simulezi prin adăugarea de Filtre Audi la obiecte. De exemplu, poti adăuga un filtru de Echo la un sunet care trebuie să fie auzit dintr-o pesteră. În situații unde obiectele se pot mișca înăuntru și afară cu un ecou puternic, poți adăuga o zona de Reverb la scenă. De exemplu, jocul tău ar putea avea mașini care conduc printr-un tunel. Dacă plasezi o zonă reverb în interioul tunelului atunci sunetele produse de motoarele mașinilor vor începe să aibă ecou când intră în tunel și să dispara atunci când iese din tunel.

Mixerul Audio al lui Unity îți permite să mixezi o multitudine de surse audio, să aplici efecte asupra lor, și să execuți masterizare.

Lucrul cu asseturi audio

Unity poate importa fisiere audio în formate AIFF, WAV, MP3 și OGG în acelasi mod ca celelalte asseturi, doar tragi de fișierele dorite în panoul proiectului. Importarea unui fisier audio crează un clip audip care poate fi tras spre o sursă audio sau folosit dintr-un script.

Pentru muzică, Unity suporta module de urmărire, care folosesc mici mostre audio ca “instrumente” și apoi aranjate să redea melodii. Modulele de urmărire pot fi importate din fișisere .xm , .mod , .it și .s3m dar în caz contrat folosite în același mod ca orice clip audio comun.

Înregistrare audio

Unity poate accesa microfonul calculatorului de la un script și să creeze clipuri audio direct prin înregistrare. Clasa Microphone oferă un API direct care caută microfoane disponibile, pune în așteptare capabilitătile lui și să înceapă/sfârșească o sesiune de înregistrare.

2.13 Opinia și concluzie

Cred ca este destul de clar că popularitatea lui Unity nu este din cauza marketingului sau al nerăbdării utilizatorilor, ci din cauza unor motive mai simple și pragmatice.

Unity a devenit posibil când memoria și resursele s-au mărit atât de mult încât optimizarea de memorie si-a pierdut locul principale în dezvoltarea jocurilor. Unity faciliteaza creare de jocuri intr-un mod agel, permițând lansări continue și prototipuri rapide, imediat ce îți dai seama cum funcționează.

Puncte negative în legatura cu Unity

Negativitățile sunt symetrice ale pozitivelor : adopția ușoara și acoperirea mare poate genera gândul și faptul că a crea orice fel de joc este ușor și gratis. Acest lucru duce spre probleme de intensitate medie. De exemplu, variabilele publice setate în instanțe prin IDE sunt folositoare în proiecte foarte simple, doar poate duce la un cod dezorganizat de-a lungul vieții proiectului.

Dar problema principală pentru mine este lipsa de produse competitive și ieftine, care te duce cu gândul când va putea oare piața de motoare grafice să intre în competiție stransă și să domine industria de jocuri indie.

Capitolul 3

aplicație – joc rpg

Apicația de joc rpg intitulat “Slayer of the Dragon” (Ucigașul Dragonului) este creată în Unity 4.6 fiind o versiune anterioară a seriei Unity lansată în anul 2014. Fată de versiunea ma noua Unity 5.xx, această versiune folosește o interfață mai veche și optimizări mai putin realizate. De asemenea, unele funcționalități cum ar fi suportul pentru VR nu a fost încă implementat în această versiune.

Unity este un motor grafic folosit de multi dezvoltatori de jocuri, în special cei indie. Oferă o gamă largă de unelte și funcționalități pentru a transforma un utilizator obițnuit intr-un programator de jocuri simple în doar cateva zile de testat/rulat anumite aplicatții.

Am ales versiunea 4.6 deoarece am vrut să dau jocului meu o atmosferă mai retro, deoarece în ziua de azi, jocurile clasice încep din nou să devină populare datorită noilor elemente de gameplay dar cu grafică clasică care conferă nostalgie oricărui veteran de jocuri.

Unity are ca cerințe de sistem foarte convenabile. Orice calculator creat după anul 2004 poate folosii primele versiuni de Unity pentru a crea simple jocuri, iar cele mai performante să creeze jocuri foarte detaliate și realiste. Cerințetele sunt :

Pentru dezvoltare

Sistem de operare: Windows 7 SP1+, 8, 10; Mac OS X 10.8+.

Placă Video: Gard graphic cu DX9 (shader model 2.0)

Pentru platforme aditiționale

iOS: Mac care rulează OS X 10.9.4 version și Xcode 6.x.

Android: Android SDK și Java Development Kit (JDK).

Windows 8.1 Store Apps / Windows Phone 8.1: 64 bit Windows 8.1 Pro and Visual Studio 2013 Update 2+.

WebGL: Mac OS X 10.8+ or Windows 7 SP1+ (doar pentru editorul pe 64- biti)

Pentru a rula jocurile Unity

-Desktop:

Sistem de operare: Windows XP SP2+, Mac OS X 10.8+, Ubuntu 12.04+, SteamOS+

Placă Video: DX9 (shader model 2.0)

CPU: support pentru setul SSE2

Web Player (depreciat) : necesită un browser care acceptă extensii (Firefox, Safari)

-iOS: requires iOS 6.0 sau mai noi.

-Android: OS 2.3.1 sau mai noi; ARMv7 (Cortex) CPU cu suport NEON și Atom CPU; OpenGL ES 2.0 sau mai noi

-WebGL: Orice versiune recentă a unui browser

-Windows Phone: 8.1 sau mai noi

-Windows Store Apps: 8.1 sau mai noi

După cum se vede, Unity poate fi folosit de către orice calculator modern și nu discrimnează utilizatorii prin incompatibilitatea De asemenea este necesar cel putin Visual Studio Express sau Pro pentru programarea scripturilor și legarea lor în obiectele jocului. Versiunea Visual Studio Pro 2008 este sucificentă pentru a crea jocuri cu mare depedență pe scripturi.

Imediat ce deschidem aplicația, ne va întâmpina o fereastră unde ne puteam crea un cont pe situl Unity pentru a ne putea salva proiectele într-un mediu Cloud fără a ne face griji de eventualele resetări ale calcualtorului.

În versiunile vechi autenficiarea era obligatorie, dar după lansarea lui Unity 5, poți intra în program sub formă de “guest” adică vizitator care poate folosii fiecare componentă a lui Unity dar pierde suportul tehnic și șansa de a încarca proiectul undeva sigur.

După ce te loghezi, vei aveti opțiunea să-ți creezi un proiect nou sau să deschizi unul deja existent. Pentru scopul prezentării proiectului. Voi deschide proiectul deja existent creat de mine folosind un pachet de asseturi/efecte/sunete/prefaburi luate din Asset Store din care a rezultat un joc RPG (Role Playing Game).

Deoarece asseturile sunt în engleză, voi traduce fiecare buton în cadrul acestui capitol pentru a putea fi înteles ce se îmtâmplă în joc. De asemenea, urmează să public acest joc pe o plaforma de distrbuție (Steam) unde urmeaza a fi vândut deîndata ce versiunea completă este terminată. Tocmai de aceea, este recomandat ca jocurile să fie făcute în engleză pentru a atrage mai mulți clienți datorită limbei internaționale a jucătorilor de rând.

3.1 Meniul principal

Jocul a fost creat în așa fel încât să poate fi accesat ușor în cadrul unui meniu principal care include următoarele butoane

Single Player – Pornește următoarea scenă în modul “un singur jucător” unde îți vei selecta personajul direct pe care vrei să-l controlezi în Aventura ta.

Network – Joc în rețea. Unde vei putea să găzduiesti proimul tău server unde se pot alătura maxim 3 jucători alături de tine pentru a te ajuta în joc

Purchase – Deoarece jocul este doar un demo, imediat ce voi termina versiunea full, vei putea să cumperi jocul de pe Steam folosind acest buton care te va redirecționa spre magazinul Steam.

New Features! – Conține DLC-uri (Downlodable Content) adică diverse elemente de gameplay care alterează modul cum arată jocul (hărți noi, înfățișare nouă perntru personaje etc.) care vor putea fi cumpărate după ce lansez jocul oficial

Figura 3.1 Meniul principal al jocului

Toate acestea au fost realizate în cadrul unei scene în care au fost adăugate diverse asseturi, animații, prefab-uri și scripturi.

Jos se observă watermark-ul adică creatorul pachetului de asseturi freeware și un site web unde putem găsii mai multe modele create de acea persoană gata să fie folosite de dezvoltatori în a crea jocuri.

3.2 Interioul jocului

Un RPG (Role-Playing Game) este un tip de joc unde jucătorii își asumă rolul de pernonaje într-o poveste de fîcțiune. Jucătorii au responsabilitate de a jiuca rolul în cadrul unor setări narative prin actorie, prin alegeri/decizii sau prin dezvoltarea caracterului în funcție de abilități, aparență și personalitate. Acțiunile luate în multe jocuri reușesc sau nu în funție de un sistem de reguli formal sau orientari.

În cadrul jocului meu, am realizat aventura unoi om oarecare în misiunea de a ucide un dragon care amenință să distrugă satul în care s-a născut.

Figura 3.2 Gameplay-ul jocului

Eroul anonim are puterea de a mânui săbii și de a folosii magie de foc. Atunci când ucide un monstru, el primește puncte de experiență care atunci cand ajunge la un anumit număr, eroul crește cu un nivel și va primii puncte de abilități pe care le poate folosii să-și îmbunătătească abilitătile și puterile.

Conform figurii 3.2, putem observa urmatoarele componente:

Buton de pauză – după apasarea lui, jocul își suspendă activatea și vei putea să salvezi sau să ieși din joc foarte ușor.

Hide Cursor (Ascunde Cursorul) – jocurile moderne oferă posibilitatea de a ascunde cursorul pentru a nu te încurca în timpul lumtei, dupa apăsarea lui încă odată, cursorul va reveni pe ecran.

Status Bar – (Bara de stare) care conferă informații despre personajul tău cum ar fi câtă viață are, câtă mana, experienața necesară pentru level și bara unde se localizeaza abilitățile.

3.3 Partea tehnică a jocului

Jocul a fost creat folosint asseturi dintr-un pachet de asseturi, combinate într-un mod unic astfel încât jocul să fie impresionabil și să atragă viitori jucători.

În cadrul acestei secțiuni, voi detalia fiecare component folosită în joc, cu exemple de cod la cum am programat inteligența artificială și acțiunile personajului.

Obiecte și materiale

Obiectele și materialele sunt de tip 3D și au fost plasate pe scenă folosind funcția de tragere după care am modificat proprietățile obiectului în fereastra de Inspector.

Figura 3.3 Exemplu de obiect sabie din cadrul jocului

Modele pot fi ușor alterate într-un program de modelare 3D după care poate fi din nou importat în Unity pentru a fi folosit în cadrul jocului. Am ales să ofer personajului și jucătorului o gama largă de arme pe care le poate cumpăra la un magazine de arme din cadrul satului.

Figura 3.3.1 Magazinul de arme

Lumini și camera.

Pentru a face jocul cât mai versatibil, am ales să introduc ambele tipuri de camera în cadrul jocului. Implicit, camera de perspectivă este cea active care urmăreste jocătorul din spate (numit și third person). Pentru a alege celălalt mod de cameră, trebuie selectezi Special Features și să dai click pe a doua optiune.

Luminile au fost plasate în așa fel încât ca atmosfera să pară una sumbră, iar fiecare zonă are tipuri de lumină specifică.

Figura 3.3.2 Lumina nopții deasupra norilor

Personajele și monștrii

Personajul principal este de sex masculin și în funcție de ce personajul pe care îl alegi la începutul jocului, poate avea cele 3 construcții ale corpului (exemplu, endomorf) pentru a oferii jucătorului posibilitatea de a alege personajul conform standardelor sale de personalitate.

Monștrii din cadrul jocului au scopul de a impiedica eroul să ajungă la destinația sa, monstrii au fost programați să atace eroul imediat ce intră în zona lui de coleziune. Fiecare monstru are anumiți parametrii specifici cum ar fi

Daunele – daunele reprezintă valori care se substrag din viață monstrului sau a eroului. Odata ajuns la 0, personajul moare și este șters din scena lumii până la repornirea jocului când va apărea din nou.

Viața – fiecare monstru are viata lui. Inițial monștrii au mai puțină viață decât eroul pentru a îi da avantaj fiind începător în lumea jocului. Cu cât eroul avansează în nivele, cu atât monștrii vor avea mai multă viață și vor fi mai greu de învins.

Sunetele

Am ales să nu include muzică de fundal deoarece am considerat că va strica atmosfera jocului. În schimb, am adăugat diverse sunete pentru fiecare acțiune din joc cum ar fi lovirea cu sabia, moartea personajului și efecte de vânt atunci când suntem la înalțime.

Hărțile

Jocul este compus din patru hărți. Fiecare hartă reprezentând o scenă custumizată cu diverse asseturi pentru a o face unică. Inițial jucătorul începe în prima hartă, dar se poate folosii de teleportare pentru a ajunge în celelalte zone. Este indicat ca jucătorul să facă cateva nivele înainte de a se teleporta intr-o zonă noua deoarece am pus restricții de nivel recomandat pentru a lupta monștrii în acea zonă.

Grafica

Cum am spus în introducere, am decis să folosesc o grafică mai veche pentru a da simț de nosltalgie. Modele 3D utilizata sunt de calitate redusă și nu au detalii foarte mari asupra texturilor. Am făcut o expenție la săbii deoarece sunt un fan mare al lor și mereu mi-am dorit să văd un joc clasic care foloseste arme fantastice moderne dar cu grafică retro.

Efecte

Fiecare abilitate sau acțiune care afectează eroul are un efect special care confer aspect visual plăcut dar și conferă informații jucătorului că eroul a fost alterat (exemplu, a crescut un nivel)

Figura 3.3.3 Efecte rezultate în urma folosirii unei abilități

Scripturi

În această sectiune voi oferii exemple de scripturi create de mine în cadrul jocului pentru a da viată obiectelor din joc. Simpla acțiune de miscare a personajului a avut nevoie de un cod sofisticat pentru a fi aplicat asupra unui model 3D și făcut referință în cadrul scenei. Voi prezenta 3 scripturi importante pentru a face un joc să fie jucabil de oricine.

Voi incepe prin a prezenta codul programării personajului cu care jucătorul poate action. În principal voi arăta partea care permite personajului să atace.

comboList reprezintă lista de animații are personajui care pot programate să interacționeze în cadrul jocului.

Prin folosirea de stadii, personajul poate continua atacul până când comanda încetează a fi folosită

După finalizarea atacului, personajul revine înapoi la starea sa idle adică de stat pe loc

În al doilea script voi arăta cum apar obiectele în lume și cum pot fi obținute de către erou sub formă de comoară.

ItemRenderer face posibilă apariția obiectului în lume. După ce scriptul este atribuit unui obiect, acesta va apărea pe jos după ce eroul învinge un inamic sau aruncă pe jos un obiect care îl are în inventoriu.

ItemManager este o bază de date din cadrul lui Unity care ține evidența obiectelor pe care inamicul sau eroul la are asupra sa.

Draw – aici reprezintă desenarea obiectelor pe care inamicii le scapă. Am setat ca inamicii care sunt uciși să ofere bani jucătorului pentru ai îi folosi să cumpere noi arme și potiuni.

În ultimul script, voi arăta cum a fost programat intelingența artificială a personajelor care oferă servicii și protecție eroului. Deoarece scriptul este mare, am decis să arat doar partea care permite eroului să obțină misiuni de la un personaj.

List reprezintă opțiunile pe care persoanjul le oferă jucătorului. Am programat astfel încat personajul să ofere misiuni, să vândă arme și potiuni și să ofere protecție impotriva monștrilor din afara orașului.

Bibliografie

http://madewith.unity.com/.

D. Dogaru, Grafică pe calculator, Editura Didactică și Pedagogică, București, 1995.

F. Ionescu, Grafică în realitatea virtuală, EdituraTehnică, 2000.

F. Moldoveanu, Z.Racoviță, Ș.Petrescu, G.Hera, M.Zaharia, Grafică pe calculator, Editura Teora, 1996.

M. Sethi, Programarea jocurilor, Editura Rosetti Educational, București, 2006.