Capitolul 1. Introducere ………………………….. ………………………….. ……………………….. 3 1.1 Rezumat… [617207]

2
CUPRINS
Capitolul 1. Introducere ………………………….. ………………………….. ……………………….. 3
1.1 Rezumat ………………………….. ………………………….. ………………………….. …………… 3
1.2 Propunerea aplicației ………………………….. ………………………….. ……………………… 3
1.3 Resursele aplicației ………………………….. ………………………….. ………………………… 3
1.4 St ructura aplicației. ………………………….. ………………………….. ………………………… 3
1.5 Introducere în Unity ………………………….. ………………………….. ……………………….. 4
Capitolul 2. Structura aplicației ………………………….. ………………………….. …………… 5
2.1 Construcția aplicației Glitch Garden ………………………….. ………………………….. … 5
2.2 Tabla de joc și aspectul ratio ………………………….. ………………………….. …………… 9
Capitolul 3. Dezvoltarea proiectului din punct de vedere al utilizatorului ……… 12
3.1 Structura pe nivele ………………………….. ………………………….. ……………………….. 12
3.2Pagina de start ………………………….. ………………………….. ………………………….. ….. 13
3.3 Pagina de opțiune ………………………….. ………………………….. …………………………. 15
3.4 Animații sprite sheet ………………………….. ………………………….. …………………….. 17
3.5 Animații Bone -Based 2D ………………………….. ………………………….. ………………. 21
Capitolul 4. Utilizarea aplicației . ………………………….. ………………………….. …………. 30
Bibliografie ………………………….. ………………………….. ………………………….. …………….. 31

3
Capitolul 1. Introducere
1.1 Rezumat

Această lucrare este constituită din 4 capitole. În primul capitol se prez intă propunerea și
structura aplicației de asemena și o serie de concepte general folosite în această lucrare. În
capitolul doi este prezentat modul de cuantificare a datelor și implementarea acestora .
Capitolul trei prezintă din punct de vedere al program atorului noțiuni care au fost folosite
pentru a crea design -ul si interfata acestei aplicații . Lucrarea se încheie cu un capitol
destinat utilizatorului, prin prezenatarea modului de utilizare a aplicației.

1.2 Propunerea aplicației

În această lucrare se dorește construirea unei o aplicații practice în Unity, sub limbajul de
programare C# ce simulează jocul Glitch Garden cu următoarele facilită ți:

 Dezvoltarea unui joc de logică pe diferite nivele de dificultate. În cazul în
care dorește, utilizatorul va putea să aleagă nivelul de dificultate. Fiecare
nivel arată diferit de asemenea se va crește și gradul de dificultate pe
parcurs .
 Această aplicație pune la încercare reflexele si logica jucătorului.
 Utilizatorul ap licației se va lupta pentru a proteja o gr adină de atacatori,
fiecare atacator si apărator având abilități speciale, unice și proprii.
 De asemenea jucătorul va trebui să se încadreze și în timpul precizat pe
fiecare nivel în parte . Aplicația se împarte pe 3 grade de dificultate, fiecare
suprinzân d cu ceva nou jucătorul.

4
1.3 Resursele aplicației
Resursele aplicației, imaginile și sunetele din fundal au fost folosite de pe:
https://www.glitchthegame.com/downloads/

1.4 Structura aplicației.
Structura aplicației este format din urmatoarele direct oare: _Scenes, cuprinzând scenele,
adică partea de front -end, Animations fiind format din toate animațiile structurate și din
sprite sheet -uri, Fonts, Images, Prefabs permite stocarea unui obiect GameObject complet
cu componente și proprietăți.
Cele prefa bricate acționează ca un șablon din care se pot crea instanțe de obiecte în
șcenă.
Orice modificări aduse unui activ prefabricat se reflectă imediat în toate cazurile produse
din acesta, dar se pot suprascrie, de asemenea, componente și setările pentru fi ecare
instanță în mod individual. Directorul Prefabs este împărțit în Attackers, Defenders,
Projectiles.
De asemenea vom avea în vedere și scripturile din: Scripts, scrise în limbajul de
programare C# și nu în cele din urma Sound cuprinzând sunetle folosi te în proiect.

1.5 Introducere în Unity

Cel mai important concept pentru a înțelege aici este paradigma orientată -obiect
(prescurtat OOP). În limbaje orientate pe obiect e, programele sunt împărțite în unități
funcționale numite obiecte. Fiecare obiect ar e propriile sale variabile și funcții
private. Funcții -obiecte specifice sunt numite metode.
Ideea aici este modularitatea: de a avea fiecare un obiect izolat, și forțând alte obiecte
pentru a interacționa c u ea prin metodele sale, putem reduce numărul de posibile

5
interacțiuni neintenționate de asemenea si bug-urile. De asemenea, creînd obiecte le
putem reutilize mai târziu cu nici o modificare. În Unity , putem construi acestor obiect e și
atașându -le la entitățile jocului .
Obiectele sunt instanț iate din clase: o clasă este doar un fișier care stabilește definiția
obiectului. Deci, dacă vrem un obiect „ Attacker “, care se ocupă de AI pentru un inamic în
joc, ai scrie o clasa „ Attacker “, și apoi atașați acel fișier pentru fiecare entitate
inamic. Când rulaț i jocul, fiecare inamic va fi echipat cu o copie a obiectului „ Attacker “.
Unity vine cu un număr de view tab de bază care pot fi stabilite în diferite moduri dupa
gustul utilizatorului. Cele cinci cele mai importante sunt tab -ul „game“, tab -ul „scene“,
tab-ul „inspector“, tab -ul „project“, iar tab-ul „hierarchy“ .
Tab-ul de joc, atunci când butonul „ play“ este apăsat, afișează o instanță a jocului pe care
utilizatorul poate interacționa cu el și de asemenea o poate testa . Tab-ul „scene “ oferă o
versiune st atică , editabil a jocului . Tab-ul „inspector“ permite utilizatorului să modifice
entități individuale din lumea jocului prin selectarea acestora în tab-ul „editor“. Tab-ul
„proj ect“ permite utilizatorului sa navigheze prin fișierele proiectului și tragă mo dule,
materiale și alte resurse în tab-ul „editor“ pentru a le plasa în joc. În cele din urmă, tab-ul
„ hierarchy “ afișează toate obiectele din lume, permițându -vă să găsiți obiectele
îndepărtate în scenă, și entități părinți unul față de celălalt, făcând clic și trăgând.

Capitolul 2. Structura aplicației

2.1 Construcția aplicației Glitch Garden
Pentru început se va construi clasa PlayerPrefManager .cs.

6
using UnityEngine;
using System.Collections;

public class PlayerPrefsManager : MonoBehaviour {

const string CHEIE_MASTER_VOLUM = "master_volum";
const string CHEIE_DIFICULTATE = "dificultate";
const string CHEIE_NIVEL = "nivel_deblocat_";

public static void SetVolumMaster(float volum)
{

if (volum >= 0f && volum <= 1f) {
PlayerPrefs.SetF loat (CHEIE_MASTER_VOLUM, volum);

} else {
Debug.LogError("Master volum afara!");

}
}

Vom avea trei constant e de tip string de valori, master_volum, dificultate, nivel_deblocat .
PlayerPref accesează preferințele jucătorilor între sesiunile de joc. Ca atare se va seta
volumul dupa cel current și se va pune între doua valori float 0 și 1.
În cazul în care volum depașeste aceste valori va fi afișat o eroare.

7
public static float Ge tVolumMaster()
{
return PlayerPrefs.GetFloat (CHEIE_MASTER_VOLUM);
}

public static void Deblocare(int nivel)
{
if (nivel <= Application.levelCount – 1) {
PlayerPrefs.SetInt(CHEIE_NIVEL + nivel.ToString(), 1); //
nivel_deblocat_(1,2,..) = 1
} else {
Debug.Log("Incerctai sa deblocati un nivel inexistent!");
}
}

În metoda GetVolumMaster() se returnează volumul current, iar metoda statică care nu
poate fi instanțiată Deblocare() va verifica dacă nivelul current este mai mic cu unul
deoarece, scena în cazul nostrum începe de la 0, iar scena finală este la nivelul 7. În cazul
în care se dovedește că jucătorul nu -I la o șcenă de nivel se va afișa um mesaj de log.
(Fig. 2.1. – Șcene)

Fig 2.1 – Șcene

8

public static bool EsteNivelulDeblocat(int nivel)
{
int valoareNivel = PlayerPrefs.GetInt (CHEIE_NIVEL +
nivel.ToString());
bool esteNivelulDeblocat = (valoareNivel == 1);

if (nivel <= Application.levelCount – 1) {
return esteNivelulDeblocat;
} else {
Debug.Log("Incerctai sa accesati un nivel inexistent!");
return false;
}
}

Metoda Este NivelulDeblocat(), va lua nivelul și va verifica dacă este deblocat, și dacă
nivelul există se returnează valoarea deblocată.

9
public static void SetDificultate(float dificultate)
{
if(dificultate >= 1f && dificultate <= 3f){
PlayerPrefs.SetFloat(CHE IE_DIFICULTATE, dificultate);
}else{
Debug.LogError("Dificultate afara din arie!");
}
}

public static float GetDificulatate()
{
return PlayerPrefs.GetFloat(CHEIE_DIFICULTATE);
}}
}

Aplicația are trei nivele, de aceea am creat metoda SetDi ficultate, care va citi o variabila
de tip float și va verifica dacă valoarea nivelului se încadreză între 1 și 3, altfel se va afișa
o eroare, iar ultima metodă va citi gradul de dificultate a jocului.

2.2 Tabla de joc și aspectul ratio
Când vorbim de st ructura și împărțirea tablei de joc al acestei aplicații trebuie neapărat sa
discutăm și despre raportul matematic adică r aportul de aspect al unei imagini și
convertirea între diferite aspecte.
De exemplu avem un ecran 4:3, în general găsite la televizoa re și la unele iPad -uri, care
reprezintă patru unități de orice fel, cum ar fi centimetri sau 40 pixeli, împărțite la 3 în
direcția opusă. (Fig. 2.2 – Raport aspect 4:3)

10

Fig. 2.2 – Raport aspect 4:3

Acest raport poate sa reprezinte și o fracție 4:3, 4 /3 ~ 1.33.
Trecerea de la 4:3 la ecranul 16:9 se va face dupa figurile de mai jos. Mai întai vom
imparți raportul 4:3 la 12:9 după figura de mai jos. (Fig 2.3 – Raport aspect 12:9)
După care vom adăuga cu roșu încă două rânduri pe fiecare parte, în dreapta și în stânga,
să obținem 16:9 . (Fig 2.4 – Raport aspect 16:9)

11

Fig. 2. 3 – Raport aspect 12:9

Fig. 2. 4 – Raport aspect 16:9

12
Toate lucrurile de mai sus ne interesează deoarece trebuie sa avem în vedere aspectul
jocului, pe diferite dispozitive cum va arăta. De aceea vom avea tabla jucătorului aratând
ca în imaginea Fig. 2.4. – Raport aspect – tablă.

Fig 2.5 . – Raport aspect – tablă

Capitolul 3. Dezvoltarea proiectului din punct de vedere al utilizatorului

3.1 Structura pe nivele

Fig. 3.1 – Structura pe nivele

13
Structura pe nivele este cea din Fig. 3.1 – Structura pe nivele. Jocul este alcătuit pe patru
categorii, 00 Splash este pagina de introducere, 01a Start și 01b Options vor fi altă
categorie, nivele de la unu pană la trei și nu în cele din urma pagina de câștig și pagina de
pierdere.

3.2 Pagina de start

Când se intra pe această pagină se va accesa acest script în care vom realiza efectul de
fade in,
In care timpul în secunde, în care se încarcă un frame este verificat cu timpul fade -ului
însine iar dacă este mai mic se va schimba culoarea treptat, modificările fiind salvate
automat, altfel această facilitate va fi falsă. Codul pentru acesta o vom găsi mai jos.

public class FadeIn : MonoBehaviour {

public float fadeTimp;

private Image panelFade;
private Color culoareCurenta = Color.black;

// folosit pentru instantiere
void Start () {
panelFade = GetComponent<Image> ();
}

void Update () {
if (Time.timeSinceLevelLoad < fadeTimp) {
//Fade in
float aChange = Time. deltaTime / fadeTimp;
culoareCurenta.a -= aChange;

14
panelFade.color = culoareCurenta;
} else {
gameObject.SetActive(false);
}
}
}

Tot aici va trebui să verificăm dacă pagina care urmea ză sa fie încarcată este nivelul
următor, iar în caz contrar vom afișa o eroare.

public class LevelManager : MonoBehaviour {

public float incarcaAutomatNivelulUrmator;

void Start()
{
if (incarc aAutomatNivelulUrmator <= 0) {
Debug.Log ("Nu s -a incarcat nivelul urmator automat, foloseste
un numar pozitiv");
} else {
Invoke ("IncarcaNivelulUrmator", incarcaAutomatNivelulUrmator);
//invoca o metoda
}

}

Butonul start va încarca pagina 0 2 Level_01, dar la încărcarea nivelului se va lua numărul
șcenei și se va adăuga unu, deoarece, prima pagina de introducere are nivelul 0, deci
pagina ca atare șcena 02 Level_01 nu va avea poziția trei, ci trei plus unu, adică patru.

15

public void LoadLevel (string name){
Debug.Log ("New Level load: " + name);
Application.LoadLevel (name);
}

public void QuitRequest(){
Debug.Log ("Quit requested");
Application.Quit ();
}

public void IncarcaNivelulUrmator() {
Application.LoadLevel(Application.l oadedLevel + 1);
}

3.3 Pagina de opțiune
De asemenea în această pagină se vor putea modifca volumul, chiar și dificultatea jocului,
savarea fiind făcută permament. Chiar și după ieșirea din aplicație se vor putea vedea
modificările făcute în el, diferența între cele două bare de la volum și cel de dificultate
este faptul că dificultatea se poate seta doar la trei nivele. (Fig. 3.2 – Opțiune)

Fig. 3.2 – Opțiune

Butonul Defaults va salva automat volumul și dificultatea aplicației prin valoarea
volumului fiind 0.8f și al dificultății 2f.

16
public class OptionsController : MonoBehaviour {

public Slider SliderVolum, SliderDificultate;
public LevelManager levelManager;

private MusicManager musicsManager;

// Use this for initialization
void Start () {
musicsManager = GameObject.FindO bjectOfType<MusicManager> ();
SliderVolum.value = PlayerPrefsManager.GetVolumMaster ();
SliderDificultate.value = PlayerPrefsManager.GetDificulatate ();
}

// Update is called once per frame
void Update () {
musicsManager.SchimbaVolumul (SliderVo lum.value);
}

public void SalveazaVolumul()
{
PlayerPrefsManager.SetVolumMaster (SliderVolum.value);
PlayerPrefsManager.SetDificultate (SliderDificultate.value);
levelManager.LoadLevel ("01a Start");
}

public void SetDefault()
{
SliderVolum .value = 0.8f;
SliderDificultate.value = 2f;
}
}

17
3.4 Animații s prite sheet.

Sprite sheet este animația cu care majoritatea item -elor cu care jucătorul va interacționa,
au fost create. Sprite sheet -urile sunt desene puse una langă alta, formând în cele din urmă
o animație.
În cazul șopârlei am luat o imagine png, iar aceasta a fost împărțită în mai multe imagine
cu ajutorul Sprite editorului, folosind următoarea formulă pentru mărimea în pixeli a unei
singure imagini:

Lățimea gridului va fi egală cu lățimea imaginii împărțită pe numărul de coloane, iar
înălțimea gridului va fi egală cu înălțimea imagii împărțită pe numărul de linii.

În acest caz rezultatul a fost 251 și 186. (Fig 3.3 – Lizard și Fig. 3.4 – Sprite Sheet)

Fig. 3.3 – Lizard

18

Fig. 3. 4 – Sprite Sheet

În continuare se va adăuga un Sprite Re nderer și un Animator, la un obiect creat la care se
va adăuga o imagine ca avatar din cele de mai sus. După care se va crea un Aimation
Controller la care se va adăuga animația.

Vom crea un nou clip nuimit Lizard Appearin g, si se vor lua toate animțiile acestei
șopârle introducândule in animație, iar pană acuma se poate vedea apariția acestei
animații.

De asemenea tot aici se vor avea în vedere starea animațiilor: un obiect poate avea un
animator, care la rândul ei o stare de animație, care va avea o ani mație de tip clip, o
tranziție și nu în ultimul rând parametrii cu sau fară condiții de tranziție.
În cazul nostru vom avea trei tranziții și trei stări Lizard Appearing, Walking și Attacking.

19
Prima stare, cu ajutorul tranziției, se va efectua doar o dată, a doua se va efectua până va
da de un obstacol, iar ultima deja când întâlnit obstacolul.
La fel ca mai sus se vor adăuga și sprite sheet -urile pentru celelalte animații, inclusiv
deplasarea șopârlei.

De asemenea pentru cactus, care este un atacator, vo m crea un Animator Controller. Vom
avea o imagine pentru principal pentru Sprite Renderer și vom adăuga imaginile în
animție, la fel ca și la ș opârlă și o vom face ca animția sa reuleze pentru 3 secunde. (Fig.
3.5. – Cactus )

Fig. 3.5. – Cactus

20
Vom crea pe lângă starea de inactive tocmai creată mai sus, un nou clip denumit At tack și
vom adăuga animația la cactus, mai exact la partea de body, astfel: vom merge pe body,
pe Sprite Render și pe Sprite .

Tot aici vom mai da un exemplu de animație, iar acesta v a fi piticul de gradină.
Vom adăuga un clip în starea de repaus a piticului vom mai adăuga tot aici un Sprte, din
body, Sprite renderer, unde vom adăuga animația în stare de repaus. La fel vom face și cu
starea lui de săritură. (Fig. 3.6 – Gnome)

Fig. 3. 6 – Gnome

Vom crea o tranziție, unde de la starea de repaus, gnomul va trece în t rei secunde la starea
de a sări, care mai târziu va evolua. (Fig.3.7 – Gnome tranzition)

21

Fig.3.7 – Gnome transition

De asemenea vom crea și piatra de mormânt (Grave stone) , având un Animator
Controller , care îl va putea adduce la viață. Acesta va avea rolul de a apăra gradina de
intruși. În acest caz nu mai trebuie adăugat în afară de starea de bază nici una nouă,
deoarece este îndeajuns să se modifice, poziția în timp al a cesteia.
De exemplu în prima secundă de frame va avea poziția 0, iar în a doua 1. Fiindcă animația
se va repeat, va da impresia că acesta se va mișca de pe loc. (Fig 3.8 – Grave stone)

Fig 3.8 – Grave stone

3.4 Animații Bone -Based 2D

Așa cum zice și nu mele animația bone -based se bazează pe componentele obiectului sau
imaginii lipite sau adăugate împreună, astfel formând o imagine.

22
Acest lucru a fost floodlit în alcătuirea obiectului: floarea de aur, partea de sus mișcându –
se, iar cea de jos rămânând nem ișcată.
Pe partea de sus, vom adăuga o transformare de rotație , schimbând rotația la diferite
interval.
Primul interval fiind la 0, urmatoarea la o valoare bine definită, iar ultima din nou la 0.
(Fig 3.9. – Bone – Based) .

Fig 3.9. – Bone – Based

Pentr u stea de asemenea se va crea un obiect atașat de floarea soarelui, care va conține un
sprite render cu imaginea acesteia. (Fig 3. 10. – Stea).

23
public float seenEverySeconds;
private float vitezacurenta ;
private GameObject currentTarget;
private Animat or animator;

void Start () {
animator = GetComponent<Animator>();
}

// Update este apelat o data pe frame
void Update () {
transform.Translate (Vector3.left * vitezacurenta * Time.deltaTime);
if (!currentTarget) {
animator.SetBool ("isAtta cking", false);
}
}

Codul de mai sus reprezintă scripul de atac al inamicilor: Attacker, unde atacatorul, în
cazul nostrum șopârla sau vulpea, vor ataca doar dacă vor întâmpina niște obstacole în
față, puse de jucător.

public void SetSpeed (float spe ed) {
currentSpeed = speed;
}

public void StrikeCurrentTarget (float damage) {
if (currentTarget) {
Health health = currentTarget.GetComponent<Health>();
if (health) {
health.DealDamage (damage);
}
}
}

public void Attack (GameOb ject obj) {
currentTarget = obj;

24
}

Viteza inamicilor se va schibmba, dar și viața acestora în funcție dacă apărătorii au fost
puși în fața lor și dacă aceștea vor araca.
Componentele și diferența de moștenire dintre ele este faptul că în loc să împărț im codul
între couă clase prin moștenire dintr -o singură clasă vom face ca ambele clase să aibă o
instanță al aceleași clase.

void OnTriggerEnter2D (Collider2D collider) {
GameObject obj = collider.gameObject;

if (!obj.GetComponent<Defender>()) {
return;
}

if (obj.GetComponent<Stone>()) {
anim.SetTrigger ("jump trigger");
} else {
anim.SetBool ("isAttacking", true);
attacker.Attack (obj);
}

Codul de mai sus face parte din Fox.cs, și se referă la faptul că dacă un obiect car e apără
are un collider pe el, ca și un fel de scut, în cazul acesta vulpea noastră nu va putea trece
mai departe. În acest caz, obiectul pe care nu îl poate depăși este lepedea.

25
Scriptul de mai jos reprezintă viața fiecărui obiect cu care interacționează jucătorul, în
funcțit de cât demage vor primi aceștea viața lor va scadea începând cu 100f.

În continuare vom avea cât va costa stea pentru a putea fi cumpărat și folost de către
utilizatorul aplicației , dar cu ajutorul careia se vor putea acumula mai multe puncte pe
parcursul jocului.

public int starCos t = 10;

private StarDisplay starDisplay;

void Start () {
starDisplay = GameObject.FindObjectOfType<StarDisplay>();
}

public void AddStars (int amount) {
starDisplay.AddStars (amount);
}

public float viata = 100f;

public void DealDamage (float damage) {
viata -= damage;
if (health < 0) {

DestoryObject ();
}
}

public void DestoryObject () {
Destroy (gameObject);
}

26

void SetMyLaneSpawner () {
Spawner[] spawnerArra y = GameObject.FindObjectsOfType<Spawner>();

foreach (Spawner spawner in spawnerArray) {
if (spawner.transform.position.y == transform.position.y) {
myLaneSpawner = spawner;
return;
}
}

Debug.LogError (name + " can't find spawner in lane");
}

bool IsAttackerAheadInLane() {
if (myLaneSpawner.transform.childCount <= 0) {
return false;
}

foreach (Transform attacker in myLaneSpawner.transform) {
if (attacker.transform.position.x > transform.position.x) {
return t rue;
}
}

return false;
}

private void Fire () {
GameObject newProjectile = Instantiate (projectile) as GameObject;
newProjectile.transform.parent = projectileParent.transform;
newProjectile.transform.position = gun.transform.position;
}

27
Scriptul din shooter verifică dacă sunt atacatori în înaintea acesteie, în caz cotrar acesta nu
va face nimic, dar dacă există un apărator acesta va ataca. În clipa în care atacatorul va
detecta un alt atactor acesta nu va fi afectat de atac.
Instanție rea, în acest caz, clonează obiectul original și returnează clona. Această funcție
face o copie a unui obiect într -un mod similar cu comanda duplicat în editor . Dacă se
clonează o obiect atunci se poate , de aseme nea, să specifice în mod opțional poziția și
rotația acestuia (acestea implicit la poziția și rotația obiesctului original , în caz contrar).

Dacă se cloneze o componentă, atunci GameObject acesta este atașat, de asemenea, va fi
clonat, din nou, cu o poziție opțională și de rotație. Când se cloneaz ă un obiect sau
component , toate obiectele și compone ntele pentru copii vor fi la fel , de asemenea, cu
proprietățile lor stabilite cum ar fi cele ale obiectului original.

În mod implicit părintele noului obiect va fi nul, deci nu va fi un „frate“ a origi nalului. Cu
toate acestea, puteți seta în continuare părintele folosind metodele supraîncărcate. În cazul
în care un părinte este specificat și nici o poziție de rotație și este specificată, poziția și
rotația a originalului se va folosi poziția obiectului clonat de la nivel local și de rotație,
sau poziția sa de rotație mondială și dacă parametrul instantiateInWorldSpace este
adevărat.

Dacă este specificată poziția și sensul de rotație, acestea vor fi utilizate ca poziția
obiectului și de rotație în spaț iu mondial. Starea activă a unui obiect în momentul clonării
va fi transmisă, astfel încât în cazul în care originalul este inactiv, atunci clona va fi creat
într-o stare inactivă .

void OnTriggerEnter2D (Collider2D collider) {
Attacker attacker = coll ider.gameObject.GetComponent<Attacker>();
Health health = collider.gameObject.GetComponent<Health>();

if (attacker && health) {

28
health.DealDamage (damage);
Destroy (gameObject);
}
}

Când două arme aruncate una spre cealaltă de către ataca tori și apărători se vor întâlni sau
ciocni, cele doua se voranula reciproc, astefel neprovocând nici o schimbare la nivelul
vieții celuilalt.

void Start () {
buttonArray = GameObject.FindObjectsOfType<Button>();

costText = GetComponentInChildren<T ext>();
if (!costText) {Debug.LogWarning (name + " has no cost ");}

costText.text =
defenderPrefab.GetComponent<Defender>().starCost.ToString();
}

Obiectul buttonArray din scriptul Button.cs, va seta starea meniul pe obiect de unde se pot
alege pentru a le introduce în joc cu rolul de apărători.
Butonul va avea culoarea imaginii din obiect în clipa în care se va da click pe aceasta.
De asemenea se vor schimba obiectele, deoarece nu se va putea pune doar un apărător
pe un moment dat.
În acest c az ele vor avea culoare neagră, adică nu vor fi active sau selec tate pentru a putea
fi folosite, acest lucru fiin d reflectat în codul de mai jos.

void OnMouseDown () {
foreach (Button thisButton in buttonArray) {
thisButton.GetComponent<SpriteRendere r>().color = Color.black;
}

29
GetComponent<SpriteRenderer>().color = Color.white;
selectedDefender = defenderPrefab;
}

Funcția CalculatePoitOfMouseCLick va avea sarcina sa găsească unde a fost dat un click
și va returna un Vector2 poziție.

Vector2 CalculateWorldPointOfMouseClick () {
float mouseX = Input.mousePosition.x;
float mouseY = Input.mousePosition.y;
float distanceFromCamera = 10f;

Vector3 weirdTriplet = new Vector3 (mouseX, mouseY,
distanceFromCamera);
Vector2 worldPos = my Camera.ScreenToWorldPoint (weirdTriplet);

return worldPos;
}

30
Capitolul 4. Utilizarea aplicației.

Acestă aplicație este un joc de strategie, care pune la încercare abilitățile de gândire,
dar este unul amuzant deoarece este plin de anim ație.
Pentru a câștiga jucătorul trebuie să pune niște piese, fiecare cu ablități speciale și unice
pentru a proteja grădina de invadatori, adică de atacatori. Printre aceste piese, vor exista
desigur, unele precum trofeul de aur sau floarea de aur, care v a garanta puncte, pentru a
asigura jucătorului că va câștiga. Aceste puncte se vor aduna și se vor putea folosi, ca să
se pună mai multe obiecte care vor proteja spațiul verde.
Desigur că există și un tip precis, pentru care jucătorul va trebui să lupte să mențină în
viață grădina, iar dacă acesta reușește va fi declarat câștigător.

31
Bibliografie

1. https://docs.unity3d.com/Manual/index.html
2. https://docs.unity3d.com/ScriptReference/Object.DontDestroyOnLoad.html
3. https://docs.unity3d.com/Scrip tReference/Vector2.html
4. https://gamedevacademy.org/unity -3d-animations -tutorial/
5. http://answers.unity3d.com/questions/931917/animate -image -ui-with-sprite –
sheet.html
6. http://blog.sokay.net/2012/11/05/2d -sprite -animation -in-
unity/ https://msdn.microsoft.com/library/windows/apps/xaml/Hh758320#change_n
otification
7. http://answers.unity3d.com/questions/828315/animated -sprite -in-ui-canvas.html