INGINERIE ELECTRICĂ ȘI TEHNOLOGIA INFORMAȚ IEI [611892]

UNIVERSITATEA DIN ORADEA
INGINERIE ELECTRICĂ ȘI TEHNOLOGIA INFORMAȚ IEI
PROGRAMUL DE STUDIU: CALCULATOARE
FORMA DE ÎNVĂȚĂMÂNT: ZI

Implementarea jocului “GO” în Unity

COORDONATOR ȘTINȚIFIC
Conf. Dr. Ing. NOVAC OVIDIU CONSTANTIN

ABSOLVENT: [anonimizat]
2018

2
Cuprins
Introducere ……………………………………………………………………………………3
Capitolul I. Generalități ……………………………………………………………………………………… ………..4
I.1. Introducere în jocul Go……………………………………………….. …………………………..4
I.2. Vocabular în jocul Go………………………………………………………………………………6
Capitolul II. U tilizare a jocului Go ………………………….. ………… ……………………………………….. .7
II.1. Reguli de bază ale jocului Go ………………………………….. ……….. ……………………7
II.2. Excepția KO …………………………………………………………… ………………………….12
Capitolul II I. Programarea jocului din punct de vedere al progra mării orientate pe obiect e…14
III.1.Introducere în C#………………………………………………………………………………….14
III.2. Clasa BoardManager…………………………………………………………………………… 19
III.2.1. DrowPiece………………………………………………………………………………… 20
III.2.2. Metoda DrowPi eceShow și DrowPie ceHide……………… ………………….. 21
III.2.3. Metoda Setup………………………………………………….. …………………………21
III.2.4. Metoda Check…………………………………………………. ………….. …………….23
III.2.5 Metoda CalculateAreaScore………………………………………………………….2 4
III.2.6 Metoda CalculateArea …………………………………….. …………………………25
III.2.7 Me toda CheckStones. ……………………………………….. …………………………26
III.2.8. Metoda GetEnemyStone…………………………………… …………………………28
III.2.9. MetodaChekIfSuicide1………………………………………………………………. 29
III.2.10. MetodaChekIfSuicide2……………………………………………………………… 30
III.3. Clasa PieceManager………………………… ………………………. …………………………3 1
III.3.1. Metoda SetValue ……………………………………………. …………………………3 1
III.3.2. Metoda OnMouseDown ………………………………….. ……………. …………..3 2
Capitolul IV. Programarea jocului din punct de vedere al interfeței în Unity……………………33
IV.1. Introducere în Unity………………………………………………… …………………………3 3
IV.2. Scena MenuScene ………………………………………………….. …………………………3 7
IV.3. Scena Rules……………………………………………………………. …………………………3 7
IV.4. Scena LevelSelector …………….. ………………………………… …………………………3 8
IV.5. Scena BoardGame Plane …………………………………………. …………………………3 9
IV.6. Game Over………………………………………………….. …………….. ……………………. 40
Concluzii …………………………………………………………………………………………………………….. ….41
Bibliografie……………………………………………….. …………………………………………………………….42

3

Introducere

Am ales jocul “Go” deoarece se bazează pe o gândire strategică. El a fost inventat în
China în urmă cu aproximativ 4000 de ani, [7] fiind introdus în Japonia în jurul anului 800, iar
în occident, la sfârșitul secolului al XIX -lea. În Asia în special, Go-ul se bucură de o
popularitate foarte mare, iar în Europa și America interesul pentru acest joc este în continuă
creștere. Posibilităț ile strategice și tactice ale Go-ului sunt nesfârșite astfel aducând o
provocare și bucurie practicanților de orice nivel. Personalitățile jucătorilor apar foarte clar pe
tabla de „Go” , [4]. Jocul reflectă foarte bine abilitatea combatanților de a menține un echilibru
între atac și apărare, flexibilitatea răspunsurilor în diferite situații, tempo -ul, acuratețea
analizei și recunoașterea punctelor tari și a slăbiciunilor adversarului.
Go-ul este un joc teritorial. Tabla marcată cu maxim 19 linii orizontale ș i maxim 19
linii verticale, poate fi vazută ca un teritoriu ce urmează a fi cucerit de către cei doi jucători.
Un jucător are un set de piese negre, numite pietre, iar celălalt, pietrele albe. Jocul începe cu
tabla goală, iar jucătorii mută pe rând, plasân d o piatră pe intersecțiile dintre liniile tablei. De
fiecare dată jucătorul ce deține culoarea neagră începe partida [8].
După ce au fost plasate pe tablă pietrele, nu mai pot fi mutate. Însă, în cazul în care ele
sunt încercuite și capturate, pietrele vo r fi ridicate de pe tablă și luate ca prizonieri. Ca
ocupație intelectuală, Go -ul este extrem de provocator: deși regulile sunt foarte simple.
Fiecare partidă iși definește rapid un caracter propriu, nu există două partide identice, [6].
Am ales acest joc deoarece sunt dezvoltate foarte bine intuiția, creativitatea,
ingeniozitatea, conceperea unui plan amplu și solid, combinat cu capacitatea de a lua decizii
rapide. Sunt câteva dintre calitățile pe care practicarea Go-ului le antrenează și le dezvoltă.
Gând irea tactică și strategică antrenată prin practică îndelungată a Go-ului are aplicabilitate în
orice domeniu din viață, gestionând at ât relațiile de parteneriat, cât și pe cele concurențiale.
Totodată, jocul induce treptat o atitudine corectă și optimă de abordare a problemelor și de
elaborare a soluțiilor.

4

Capitolul I. Generalități

I.1 Introducere în jocul Go

În acest capitol vom construi o aplicație care simulează jocul Go. Există o serie de
reguli pe care trebuie să le întelegem (din punct de vedere al algoritmilor).
Pe scurt, obiectivul jocului este de a delimita cu pietrele proprii, un număr cât mai
mare de puncte. Regul ile de joc pot fi învățate cu ușurință , fiind foarte simple . În ciuda
faptului că regulile sunt simple, Go este un joc com plex. [5].
Pietrele sunt de două feluri, albe și negre. Ele sunt așezate pe tablă pe rând de către
jucători.Spre deosebire de șah, aici negrul începe întotdeauna . Dacă există o diferență tehnică
mare între jucători, atunci jucătorul cu mai puțină experienț ă, primește un număr de pietre în
avans (handicap) [4].

Figura I.1 Tabelă standard de Go

5
Orice piesă se așază la intersecția liniilor . Astfel, o piatră dispusă undeva dincolo de
prima linie și coloană, va avea patru interesecții înconjurătoare (numite libertăți, de fapt
cele patru linii, din N, S, E și V) libere. O piatră aflată pe prima linie va avea doar
trei interesecții (libertăți, linii) libere, iar una la colț va avea două intersecții (libertăți,
linii) libere.
Orice piatră sau grup de pi etre se poate captura cu extragerea pietrelor de pe tablă
dacă nu au nici o libertate ( intersecții libere înconjurătoare), adică sunt înconjurate de
pietrele oponente. Minimul cerut pentru supraviețuire al grupul ui este de două intersecții
(libertăți) interne și neconectate, [9].
Sinuciderea este interzisă (plasarea unei pietre într -una din intersecțiile înconjurate de
către pietrele adverse). Este admisă o astfel de mutare doar în cazul în care oponentul
pierde prin această mutare ultima lui libertate ceea ce duce la capturarea pietrelor lui.
O piesă nu poate fi așezată într -un punct (intersecție) specific, dacă reface un ciclu de
joc anterior parcurs.
Dacă un jucător joacă “pass”, oponentul său poate așeza o nouă piatră ; iar dac ă ambii
joacă “pass” jocul se încheie.
Jucătorul de GO are patru obiective: să înconjoare teritoriul, să diminueze teritoriul
adversarului, să captureze pietrele adversarului și să -și apere propriile pietre. Întotdeauna
cel care învinge dovedește că a reușit să realizeze, în mod echilibrat, aceste obiective mai
eficient decât adversarul său.
Partida se încheie după două mutări “pas” consecutive. Spunând “pas”, jucătorul se
referă la faptul că nu vede nici o posibilitate de a mai avansa în realizarea vreunui obiectiv
din cele patr u menționate mai sus. O mutare “pas” presupune ca toate teritoriile să fie
înconjurate complet (toate secțiunile din “zid” să fie la locul lor) și nici o piatră să nu fie
în atari de-a lungul graniței comune.
O altă modalitate de încheiere a unei partide e ste prin abandon. De obicei, un jucător
va abandona o partidă care a devenit dezechilibrată și deci, neinteresantă pentru
adversarul său. Dacă se pierd prea multe pietre, pur și simplu se abandonează și se începe
o nouă partidă. Scorul final:
Pentru scorul final avem 2 lucruri care trebuie să le luăm în considerare. Primul lucru
este câte pietre are fiecare jucător pe tablă, ele se adaugă scorului teritorial. Scorul
teritorial înseamnă numărarea spaților înconjurate de către fiecare jucător. Jucătorul cu
mai multe puncte va câștiga meciul.

6

I.2. Vocabular în jocul Go

adiacent – punctul următor pe tablă de -a lungul unei linii
atari – situație în care un grup de pietre a rămas cu o singură libertate
captură – ocuparea tuturor libertăților unui grup și îndepărtarea lui de pe tablă
doi ochi – două puncte separate înconjurate de un grup de pietre
extindere – o piatră adăugată unui grup pentru a obține mai multe libertăți
grup – una sau mai multe pietre legat e
ko – situație în care se poate captura și recaptura
legătură – pietre de aceeași culoare plasate pe puncte adiacente; unirea unui grup cu
altul
libertate – punct neocupat, adiacent unui grup
mort – grup de pietre care nu poate forma doi ochi și nici nu poate fi legat de altul viu
neutru – punct liber care nu poate fi înconjurat de nici unul din jucători
ochi – unul sau mai multe puncte complet înconjurate de pietre de aceeași culoare
pas – mutar e neefectuată de către unul dintre jucători
piatră – piesă de joc, neagră sau albă
prizonie r – piatră care a fost îndepărtată de pe tablă ca urmare a unei capturi
punct – loc în care două linii se ating pe tablă; unitate de măsură pentru scor
teritoriu – punctele de pe tabla de GO; puncte înconjurate complet de unul dintre
jucători
viu – grup de pietre care a reușit să înconjoare doi ochi

7
Capitolul II. Utilizarea jocului GO

II.1 Regulile de bază ale jocului GO

Teoretic în joc se utilizează o rezervă nelimitată de pietre. Jucătorul “negru” începe partida
întotdeauna (numărul 1 și numărul 3), pe urmă jucătorul alb continuă să -și plaseze și el
piesele (piesele cu numărul 2 și 4) , așteptându -și fiecare ordinea [1].
Pietrele se plasează pe tablă doar la intersecțiile caroiajului. (după cum se poate vedea în
figura de mai jos, Figura II.1 )

Figura II.1 Plasarea pietrelor pe tabla de joc

8
Lanț de pietre conectate

Un ”lanț” este format din mai multe pietre care sunt de aceeași culoare și sunt
conectate prin intermediul liniilor caroiajului tablei (după cum se poate observa în figura e
mai jos, Figura II.2.) , [15].
Când o piatră sau un lanț este înconjurat de pietrele adversarului atunci ele nu mai au
libertăți, sunt capturate și sunt date jos de pe tablă.
Jocul “Go” e mai mult decât a captura și a nu fi capturat . De exemplu, mai multe
pietre adunate împreuna pot forma grupuri. Dacă jucatorul “negru” dorește să -și salveze o
piatră, poate forma un grup ce devin e mai puternic dacă pietrele sunt conectate.

Figura II.2 Lanț de pietre conectate

9

Libertăți

Figura II.3. Patru libertăți Figura II.4. Trei libertăți

Figura II.5. Două libertăți Figura II.6 O libertate

În diagramele de mai sus, piatra neagră are: patru libertăți în Figura II.3., trei libertăți
în Figura II.4, două libertăți în Figura II.5 și o singură libertate în Figura II.6. Despre piatra
din Figura II ..6 se spune că este în atari , adică riscă ca la următorea mutare să fie capturată.
La un lanț sau un grup de pietre conectate, fiecare piesă are un număr de libertăți egal cu cel
al grupului.

10
Capturarea pietrelor [20].

Dacă în urma unei mutări (plasare a unei pietre pe tablă), o piatră sau un grup de pietre
a adversarului își pierd toate libertățile, grupul se va extrage de pe tablă: a fost capturat.
Numărul lor se va aduna la finalul partidei la numărul de puncte încercuite.
Astfel, în diagrama de mai jos din stânga (Figura II.7) dacă va fi rândul jucătorului ce deține
pietrele negre, el va putea captura două pietre albe așezând o piesă pe punctul a.

Figura II.7 Figura II.8 Figura II.9

A doua diagr amă (Figura II.8) reprezintă adăugarea a încă o piatră neagră, in partea dreaptă
(a) rămasă liberă, astfel reușește să captureze ambele pietre albe înconjurate de pietrele
negre.
Sunt grupuri de pietre care însă pot evita capturarea datorită regulii care nu permite
sinuciderea. În prima figură de mai sus, jucătorul negru îi taie toate libertăț ile jucătorului alb.
Orice piatră capturată devine prizonier. Pentru fiecare piatr ă captura tă, un punct este s căzut
din suma totală a teritoriu lui respectivului jucător. La fel e și în cazul capturării grupurilor de
pietre. Toate pietrele capturate sunt scoase de pe tablă și le păstrează oponentul. Totodată și
teritoriul unde se aflau pietrele, se transferă în posesia jucătorului care a capturat pietrele.

11

Supraviețuirea grupului

Pentru ca un grup să supraviețuiască , trebuie să aibă minimum două libertăți care nu
pot fi eliminate. Prima diagrama prezinta un exemplu elementar al unui gr up care
supravietuieste pe tablă . Acest grup are doi ochi (Figura II.10 ), adică două libertăți int erne
separate. Grupul al doilea (Figura II.11), este similar primului, dar are mai mult teritoriu, iar
cea de -a treia diagram (Figura II.12), prezintă configurația minimă pentru supraviețuire la colț
ale celor două grupuri.

Figura II.10 Figura II.11 Figura II.12

Sinuciderea este interzisă

Orice mutare ce duce la anihilarea ultimei libertăți a unui grup de pietre se consideră
ca fiind sinucidere și este interzisă. Pract ic, mutarea pietrei negre în intersecția notată cu cerc
roșu este interzisă. În diagramele de mai jos (figurile II.13, II.14 și î n figura II.15) negrul nu
poate muta în intersecția marcată cu cerc roșu, deoarece s -ar sinucide. Spre deosebire de
jucatorul “ negru”, “albul” poate juca în aceste puncte, în a doua diagramă anihilându -și
libertatea (deci mișcare fără sens), iar în celelalte cazuri duce la capturarea pietrelor negre.

12

Mai jos sunt 3 cazuri (exemple) de sinucidere interzis e în jocul GO
Figura II.13. Primul caz Figura II.14 Al doilea caz Figura II.15. Al treilea caz

Excepția de la această regulă este situația în care ocuparea ultimei libertăți a unui grup
de pietre conduce la capturarea unui grup advers.

II.2. Excepția KO

Figura II.16 KO

13
Observăm în această figură faptul c ă dacă „negrul” dorește să captureze „albul ”,
„albul ” ar putea apoi să manânce „negrul ”. Pentru a nu se forma o buclă nesfârșită, cum
nu este permis să se repete situația ”pe întreaga tablă”, numai odată cu plasarea în altă
parte a unei pietre (sau a mai multora), se permite luarea înapoi a pietrei ko. Când este
importantă capturarea (câștigarea ko-ului), aceste mutări în altă parte de obicei ame nință ceva
anume, astfel oponen tul este nevoit să răspundă l a ele, neavând timp să conecteze ko-ul.
Aceste mutări se numesc ”amenințări ko”. Cuvântul ko înseamnă eternitate. În jocul GO,
termenul ko se referă la o poziție des întâlnită, care ar duce la o serie nesfârșită de mutări
inutile dacă nu ar exista o regulă pentru asta. Exemplul de mai sus (Figura II.16) prezintă
poziția de ko.

14
Capitolul III. Programarea jocului din punct de vedere al
programării orientate pe obiecte, C#

III.1 Introducere în C# [29].
Ca parte a ansamblului strategiei .NET, dezvoltată de Microsoft, la finalul anilor ’90 a
fost creat limbajul C#. El este direct înrudit cu C, C++ și Java. “Bunicul” limbajului C# este
C-ul. De la C, C# moșteneste sintaxa, multe di n cuvintele cheie și operatorii, [2], [26].
De asemenea, C# construiește peste modelul de obiecte definit în C++. Relația dintre
C# și Java este mai complicată. Java derivă la rândul său din C și C++. Ca și Java, C# a fost
proiectat pentru a produce cod portabil. [10].
Limbajul C# nu deri vă din Java. Între C# și Java există o relație similară celei dintre
“veri”, ele derivă din același strămoș, dar se deosebesc prin multe caracteristici importante.
Limbajul C# conține mai multe facilităti inovatoare, dintre care cele mai im portante
se referă la suportul î ncorporat pentru componente software. C# dispune de facilități care
implement ează direct elementele care alcă tuiesc componentele software, cum ar fi
proprietățile, metodele și evenimentele. [27].
Poate cea mai importantă facilitate de care dispune C# este posibilitatea de a luc ra
într-un mediu cu limbaj mixt, [3].
Principiile programării orientate pe obiect, metodologiile de programare s -au
modificat continuu de la apariția calculatoarelor pentr u a ține pasul cu mărirea complexit ății
programelor. Pentru primele calculatoare , programarea se făcea introducând instrucțiunil e-
mașină scrise în binar. Pe mă sură ce programele au crescut , a apărut și limbajul de asamblare,
în acest limbaj se puteau gest iona programe mai mari prin utilizarea unor reprezentări
simbolice. Cum programele continuau să se mărească, s -au introdus limbaje de nivel inalt,
precum FORTRAN și COBOL, iar apoi a apărut programarea structurată .
Astfel programarea orientată pe obi ecte a luat cele mai bune idei de la programarea
structura tă, combinându -le cu concepte noi, [11].
De aici a rezultat o modalitate difer ită de a organiza un program. De fapt, un program
poate fi organizat în două moduri: în jurul codului (mod de lucru descris d e sintagma “codul
acționează asupra datelor”, valabil în cazul programării structurate) sau în jurul datelor
(abordarea descrisă de sintagma “datele controlează accesul la cod”, valabilă în cazul

15
programării orientate pe obiect e). Toate limbajele programăr ii orientate pe obiect e au prezente
patru caracteristici comune precum : încapsularea, polimorfismul, moștenirea și reutilizarea.
Încapsularea este un mecanism care combină codul și datele pe care le manipulează ,
menținând integritatea acestora față de int erferența cu lumea exterioară. Încapsularea mai este
numită și “realizarea de cutii negre”, deoarece se ascu nde funcționalitatea proceselor, [23].
Când codul și datele sunt încapsulate , se crează un obiect. În cadrul unui obiect, codul și
datele pot fi publice sau private. Codul și datele private sunt accesibile doar în cadrul aceluiași
obiect, în timp ce codul și datele publice pot fi utilizate și din părți ale programului care există
în afara acelu i obiect. Unitatea fundamentală de încapsulare este clasa. Clasa specifică datele
și codul care operează asupra datelor. O clasă definește forma unui obiect. Sau altfel spus, o
clasă reprezintă o matriță, iar un obiect reprezintă o instanță a clasei, [11].
Polimorfismul este calitatea care permite unei interfețe să aibă acces la un grup generic
de actiuni. Termenul este deriv at dintr -un cuvânt grecesc avâ nd semnificația “cu ma i multe
forme”. Spre exemplu, să presupu nem că avem o nevoie de o rutină care să r eturneze aria unei
forme geometrice, care poate fi un tr iunghi, cerc sau trapez. Întru cât ariile celor trei forme se
calculează diferit, rutina trebuie să fie adaptată la datele pe care le primește încât să distingă
despre ce fel de formă este vorba și să returneze rezultatul corect. Conceptul de polimorfism
este exprimat prin sintagma “o singură interfață , mai multe metode”, [3].
Moștenirea este procesul prin care un obiect poate dobândi caracteristicile altui obiect.
Analogia cu conceptul de animal est e elocventă. Spre exemplu, să consideram o reptilă .
Aceasta are toate caracteristicile unui animal, însă în plus are și o al tă caracteristică, și anume:
sângele rece. Să considerăm un ș arpe. Acesta este o reptilă lungă și subțire care nu are
picioare. Șarp ele are toate caracteristicile unei reptile, însă posedă și propriile sale
caracteristici. Așadar, un șarpe moșteneste caracteristicile unei reptile. O reptilă moștenește
caracteristicile unui animal. Așadar, mecanismul moștenirii este cel care face posibi l ca un
obiect să fie o instanță a unui caz mai ge neral, [10].
Reutilizarea este atunci când este creată o clasă, aceasta poate fi utilizată pentru a crea
o mulțime de obiecte. Prin utiliz area moștenirii și încapsulării, clasa amintită poate fi
reutilizată . Nu mai este nevoie să testăm codul respectiv ci doar să îl utlizăm correct, [23.]
Noțiuni ale limbajului de programare C#
Clasa: o aplicație C# este o coleție de clase, tipuri și structuri, o clasă este o mulțime
de date și metode, o aplicație C# poate fi formată din mai multe fișiere, însă o clasă nu se
poate să apară în mai multe fișiere.

16
Metoda Main: astfel desemnăm Main ca și puncul de intrare în program, când se
termină fun cția Main , aplicația se încheie. [10].
Namespace -ul System este cel mai folosit namespace
Clasa “Console ” furnizează acces la intrarea standard, ieșirea standard și stream -urile
standard pentru erori
Practici recomandate: comentarea aplicaților, generarea de documentație XML,
demonstrație și tratarea excepțiilor.

C# simplifică mult scrierea de programe pentru sistemul de operare Windows .
Exemplu de program simplu Windows scris în Managed C++ ( C++/CLI) și C#:

Astfel avem mai jos un exemplu de c od scris în Managed C++ ( C++/CLI), [28]:

public:
int main(array<System: :String ^> ^args)
{
// Activarea efectelor vizuale Windows XP înainte de crearea oricărui control
Application::EnableVisualStyles();
Application::SetCompatibleTextRenderingDefault(false);

// Crearea și rularea ferestrei principale
Application::Run(g cnew Form1());
return 0;
}

Codul de mai jos este scris în C#:
public static void Main()
{

Form1 form1 = new Form1();
form1.Show();
Application.Run(form1);

17
}

Limbajul de programare C++ a fost inițial derivat din C. Totuși, nu absolut orice program
scris în C este valid C++. Deoarece C și C++ au evoluat independent, au apărut, din
nefericire, o serie de incompatibilități între cele două limbaje de programare . Cea mai amplă
revizie a lim bajui C, C99, [21], a creat un număr suplimentar de conflicte. Diferențele fac să
fie greu de scris programe și biblioteci care să fie compilate și să ruleze corect în calitate de
cod C sau C++, și produce confuzii celor care programează în ambele limbaje. Diferențele fac
ca fiecare din cele două limbaje de programare să împrumute din caracteristicile celuilalt
limbaj de programare.

Diferenț ele d intre limbajul de programare C ș i C#
Exemplu [22]:

Un program care citește un număr întreg și îl afișează.
C:
#include <stdio.h> /* conț ine declar ațiile funcțiilor de intrare/ieș ire */
int main() /* program principal */
{
int i;
printf("Introduceț i un nr:");
scanf("%d",&i); /* citire număr introdus la tastatură */
printf("%d", i); /* afișare număr citit */
return 0;
}

C#:
#include <iostream> //conține declarațiile funcțiilor de intrare/ieșire

int main() //program principal
{
int i;

18
std::cout<<"Introduceț i un nr:";
std::cin>>i; //citire
std::cout<<i; //afișare
return 0;
}

După procesul de standardizare ANSI, specificațiile limbajului de programare C au rămas
nemodificate pentru o perioadă, în timp ce „C++” a continuat să evolueze , [25] .
(Amendamentul Normativ I a creat o nouă versiune a limbajului C în 1995, dar această
versiune este prea puțin cunoscută.) Totuși, la sfârșitul anilor 1990, standardul a suferit o
revizie, conducând la publicarea standardului ISO 9899:1999 în anul 1999 . Acest standard
este cunoscut sub numele „C99“. A fost adoptat ca standard ANSI în martie 2000 , [22].

Diagramă cu proprietățile limbajului de programare C# , [17]

19
Astfel regăsim limbajul de programare C# având câteva atribute, [27]:

1. Simplu
2. Limbaj de programare modern
3. Orientat pe obiecte
4. Cod “ Type Safe” ce acceseaz ă doar memoria locației cu acces autorizat
5. Interopera biliatea (p roces ce permite programelor C# să facă aproape orice poate să
facă o aplicație nativă C++)
6. Scalabil si Actualizabil
7. Orientat pe componente
8. Limbaj de programare structurat (codul poate fi “rupt” in mai multe părți folosind
funcții, ceea ce îl face mai ușor de înțeles)
9. Bibliotecă vastă
10. Viteză (C# dispu ne de multe funcții încorporate ceea ce duce la o mai rapită dezvoltare
[17].

III.2. Clasa BoardManager

În această clasă avem instanțiat algoritmul jocului, astfel avem pentru început o variabilă
Player care reține ce jucător trebuie să facă mutarea. Am creat o listă de obiecte unde se
stochează matricea ce reprezintă tabla de joc. Tabla de joc este inițial de 5 linii și 5 c oloane pe
care se supra scrie mai apoi în funcție de num ărul de coloane dorit din clasa
LevelSelectorManager.

20
Figura III.1. BoardManager

În clasa BoardManager avem inițializate următoarele metode:

III.2.1. DrowPiece
În această metodă desenăm pietrele de joc în formă de sferă pe un panel.

Figura III.2. DrowPiece

public class BoardManager : MonoBehaviour
{

public static int Player = 1;

static List<List<GameObject>> board;

int[,] boardInt = new int[boardSize, boardSize];

public static int boardSize = 5;
private float pieceSize = 4;

static int Size = 0;
public static int PassNr = 0;

public static int ScorePlayer1 = 0;
public static int ScorePlayer2 = 0;

static int[,] moveback1;
static int[,] moveback2;

GameObject DrawPiece( float x, float y)
{
var panel = GameObject.Find( "Plane");

GameObject cube = GameObject.CreatePrimitive(PrimitiveType.Sphere);
cube.transform.SetParent(panel.transform, false);
cube.AddComponent<PieceManager>();
cube.transform.position = new Vector3(x, 0.35f, y);

float f = 1.7f;

f = (10 / ( float)boardSize) – 0.2f;
cube.transform.localScale = new Vector3(f, 0.8f, f);
return cube;
}

21
III.2.2. Metoda DrowPiceShow și DrowPieceHide

În aceste doua metode pietrele sunt existente , doar că atunci când se plasează o piesă
aceasta se arată, iar în momentul în care adversarul capturează o piesă se a pelează
DrowPieceHide astfel ducând piatra din nou sub tabla de joc.

Figura III.3. Tabla de joc în Unity

public static void DrawPieceHide( int x, int y)
{
board[x][y].transform.position = new Vector3(board[x][y].transform.position.x,
-0.56f, board[x][y].transform.position.z);
}

public static void DrawPieceShow( int x, int y)
{
board[x][y].transform.position = new Vector3(board[x][y].transform.position.x,
0.35f, board[x][y]. transform.position.z);
}
Figura III.4. Ascunde și arată piatra

III.2.3. Metoda Setup

În această metodă reinițializăm valorile statice de ficare dată când un joc este gata
pentru a reseta scorul și pentru a pu tea începe jocul din nou cu jucă torul cu pietrele negre.

22
De asemenea se declară și se inițializează tabla de joc, se desenează sferele și linile orizontale
și verticale de joc.
Verificarea excepției ko se face tot în metoda Setup, astfel ținem minte ultimele două
mutări pentru a nu mai putea fi repetate la infinit de către jucători. După alte două mutări
diferite se poate relua mutarea.

private void Setup()
{
Player = 1;
PassNr = 0;
ScorePlayer1 = 0;
ScorePlayer2 = 0;;
Size = boardSize – 1;
pieceSize = 20 / ( float)boardSize;
var startX = 0 – boardSize / 2 * pieceSize;
var startY = 0 – boardSize / 2 * pieceSize;

board = new List<List<GameObject>>();
for (int i = 0; i < boardSize; i++)
{
var row = new List<GameObject>();
for (int j = 0; j < boardSize; j++)
{
var gameObject = DrawPiece(startX + pieceSize * i, startY + p ieceSize
* j);
if (j == 0)
{
LineRenderer lineRenderer =
gameObject.AddComponent<LineRenderer>();
lineRenderer.widthMultiplier = 0.1f;
lineRenderer.SetPosition(0, new Vector3(startX + pieceSize * i, 0,
startY + pieceSize * j));
lineRenderer.SetPosition(1, new Vector3(startX + pieceSize * i, 0,
startY + pieceSize * Size));
lineRenderer.material.color = Color.black;
}
if (j==1)
{
LineRenderer lineRenderer =
gameObject.AddComponent<LineRenderer>();
lineRenderer.widthMultiplier = 0.1f;

lineRenderer.SetPosition(0, new Vector3(startX + pieceSize * 0, 0,
startY + pieceSize * i));
lineRenderer.SetPosition(1, new Vector3(startX + pieceSize * Size,
0, startY + pieceSize * i));
lineRenderer.material.color = Color.black;
}

row.Add(gameObject);
}
board.Add(row);
}

moveback1 = new int[board.Count, board[0].Count];
moveback2 = new int[board.Count, board[0].Cou nt];

23

for (int i = 0; i < board.Count; i++)
{
for (int j = 0; j < board[i].Count; j++)
{
moveback1[i, j] = GetValue(i, j);
moveback2[i, j] = GetValue(i, j);
SetValue(i, j, 0);
DrawPieceHide(i, j);
}
}
Figura III.5. Metoda Setup

III.2.4. Metoda Check

În această metodă verificăm dacă se execută mișcarea pe poziția pe care s -a pus piatra,
se verifică dacă nu este deja o alta piesă dacă nu este sinucidere sau dacă nu este ko. Mai întâi
se copiază valorile din tabla de joc într -o variabilă auxiliară mai ap oi se execută mișcarea dacă
este posibilă și apoi se reinițializează tabla de joc la valorile inițiale

public static bool Check(int x, int y, int player)
{
if (GetValue(x, y) != 0)
{
return false;
}

int reversePlayer;
if (player == 1)
{
reversePlayer = 2;
}
else
{
reversePlayer = 1;
}

int[,] aux = new int[board.Count, board[0].Count];
for (int i = 0; i < board.Count; i++)
{
for (int j = 0; j < board[i].Count; j++)
{
aux[i, j] = GetValue(i, j);
}
}

Move(x, y, player);

bool isko = true;

for (int i = 0; i < board.Count; i++)
{
for (int j = 0; j < board[i].Count; j++)
{

24
if (GetValue(i, j) != moveback2[i, j])
{
isko = false;
}
}
}

Figura III.6. Check

III.2.5 Metoda CalculateAreaScore

Aceasta este prima metodă de punctare a scorului.
În această metodă calculăm pentru a stabili scorul, câte pietre are pe tablă fiecare
jucător, scorul se actualizeaza instant pe tabla de joc .

static void CalculateAreaScore()
{
int player1 = 0;
int player2 = 0;
for (int i = 0; i < board.Count; i++)
{
for (int j = 0; j < board[i].Count; j++)
{
DrawPieceHide(i, j);
if (GetValue(i, j) == 1)
{
player1++;
DrawPieceShow(i, j);
}
if (GetValue(i, j) == 2)
{
player2++;
DrawPieceShow(i, j);
}
}
}
int player1Area = 0;
int player2Area = 0;
player1Area = CalculateArea(1);
player2Area = CalculateArea(2);
ScorePlayer1 = player1 + player1Area;
ScorePlayer2 = player2 + player2Area;
Player1Manager.UpdateScore(ScorePlayer1);
Player2Manager.UpdateScore(ScorePlayer2);
}
Figura III.7. Scorul pietrelor

25

III.2.6 Metoda CalculateArea

În ace astă metodă parcurgem cea de -a doua parte pentru calcularea scorului și anume
partea în care se verifică câte intersecții au înconjurat fiecare jucător. Pen tru asta am mutat
tabla de joc î ntr-o auxiliară pentru aflarea scorului pen tru jucătorul cu pietrele negre. A m
schimbat toate spați ile goale în spați i cu pietre albe, după aceea am verificat care din pie trele
albe se sinucid, ca urmare acelea aveau să fie î nconjurate de piatre negre adău gându-se la
punctajul jucătorului cu piatre negre ca fiind pietre mâncate. Acel ași lucru se face și pentru
pietrele d e culoare albă, astfel actualizâ ndu-se scorul.

private static int CalculateArea( int player)
{
int playerEnemy;
if (player == 1)
{
playerEnemy = 2;
}
else
{
playerEnemy = 1;
}

int[,] aux = new int[board.Count, board[0].Count];
for (int i = 0; i < board.Count; i++)
{
for (int j = 0; j < board[i].Count; j++)
{
aux[i, j ] = GetValue(i, j);
if (GetValue(i, j) == 0)
{
SetValue(i, j, playerEnemy);;
}
else if (GetValue(i, j) == playerEnemy)
{
SetValue(i, j, 0);
}
}
}
List<vec> CanBeEaten = new List<vec>();
for (int i = 0; i < board.Count; i++)
{
bool check = true;
for (int j = 0; j < board[i].Count; j++)
{
check = true;
foreach (vec v in CanBeEaten)
{
if(v.x == i && v.y == j)
{
check = false;
}
}

26

if (GetValue(i, j) == playerEnemy && check)

{
CheckIfSuicide(i, j, player, CanBeEaten);
}
}
}

for (int i = 0; i < board.Count; i++)
{
for (int j = 0; j < board[i].Count; j++)
{
SetValue(i, j, aux[i, j]);
}
}

return CanBeEaten.Count;
}
Figura III.8. Calcularea Scorului

III.2.7 Metoda CheckStones

În această metodă se verifică pentru fiecare piesă ce inamici și ce prieteni (pietrele de
aceeași culoare) astfel se verifică pentru coordonatele x și y sus, jos, stânga, dreapta ce are în
vecinătatea lor. Dacă piatra se află la colțuri sau margine ce este în afara tablei de joc se
consideră inamic.

static vec checkStones( vec l, int player)
{
int playerEnemy;

int x = l.x;
int y = l.y;

if (player == 1)
{
playerEnemy = 2;
}
else
{
playerEnemy = 1;
}
if (x > 0)
{
if (GetValue(x – 1, y) == playerEnemy)

{
l.a++;

27
}
else if (GetValue(x – 1, y) == player)
{
l.e++;
}
}
else
{

l.e++;
}
if (x < Size)
{
if (GetValue(x + 1, y) == playerEnemy)
{
l.a++;
}
else if (GetValue(x + 1, y) == player)
{
l.e++;
}
}
else
{
l.e++;
}

if (y > 0)
{
if (GetValue(x, y – 1) == playerEnemy)
{
l.a++;
}
else if (GetValue(x, y – 1) == player)
{
l.e++;
}
}
else
{
l.e++;
}
if (y < Size)
{
if (GetValue(x, y + 1) == playerEnemy)
{
l.a++;
}
else if (GetValue(x, y + 1) == player)
{
l.e++;
}
}
else
{
l.e++; } return l;
Figura III.9. Metoda CheckStones

28
III.2.8. Metoda GetEnemyStone

Dacă în metoda “CheckStones” se verifica ce piet re se află în jurul fiecăruia, î n
această metodă se verifică aceleași lucruri pentru a se captura pietrele înconjurate după
efectuarea mutării , dacă este necesar.

static List<vec> getEnemyStone( int x, int y, int player)
{
int playerEnemy;
List<vec> e = new List<vec>();
if (player == 1)
{
playerEnemy = 2;
}
else
{
playerEnemy = 1;
}
if (x > 0)
{
if (GetValue(x – 1, y) == playerEnemy)
{
vec a = new vec();
a.x = x – 1;
a.y = y;
e.Add(a);
}
}

if (x < Size)
{
if (GetValue(x + 1, y) == playerEnemy)
{
vec a = new vec();
a.x = x + 1;
a.y = y;
e.Add(a);
}
}
if (y > 0)
{
if (GetValue(x, y – 1) == playerEnemy)
{
vec a = new vec();
a.x = x;
a.y = y – 1;
e.Add(a);
}
}
if (y < Size)

29

{
if (GetValue(x, y + 1) == playerEnemy)
{
vec a = new vec();
a.x = x;
a.y = y + 1;
e.Add(a);
}
}
return e;
Figura III.10. GetEnemySton e

III.2.9 Metoda CheckIfSuicide

În această metodă se verifică dacă este sinucidere, dacă rezultă că este sinucidere,
mutarea nu poate fi efectuată.

private static bool CheckIfSuicide( int x, int y, int player)
{
vec l = new vec();
l.x = x;
l.y = y;
checkStones(l, player);
List<vec> toBeEatenStones = new List<vec>();
toBeEatenStones.Add(l);

RecLogic(l, player, toBeEatenStones);
bool canEat = true;
foreach (vec ci in toBeEatenStones)

30

{
if (ci.a + ci.e != 4)
{
canEat = false;
}
}

if (canEat)
{
return false;
}
return true;
}
Figura III.11. Verifică dacă e sinucidere

III.2.10 MetodaChekIfSuicide

În această metodă se verifică pe același algoritm dacă după plasarea unei pietre,
pietrele vecine poti fi înco njurate de inamici astfel rezultând capturarea acestora.

private static void CheckIfSuicide( int x, int y, int player,List<vec> ate)
{
vec l = new vec();
l.x = x;
l.y = y;
checkStones(l, player);
List<vec> toBeEatenStones = new List<vec>();
toBeEatenStones.Add(l);

RecLogic(l, player, toBeEatenStones);
bool canEat = true;
foreach (vec ci in toBeEatenStones)
{

if (ci.a + ci.e != 4)
{

31

canEat = false;
}
}

if (canEat)
{
ate.AddRange(toBeEatenStones);
}
}
Figura III.12. Verifică vecini i

III.3 Clasa PieceManager

III.3.1 Metoda SetValue

În această metodă în momentul în care jucătorii apasă pentru a -și poziționa pietrele,
ele se fac în culorile nergru și alb în funcție de jucătorul căruia îi este rândul.

public void SetValue( int value)
{
Value = value;

var renderer = GetComponent<Renderer> ();
if (Value == 1) {
renderer.material.color = Color.black;
BoardManager.DrawPieceShow(x, y);
} else if (Value == 2) {
renderer.material.color = Color.white;
BoardManager.DrawPieceShow(x, y);
} else {
renderer.material.color = Color.black;
BoardManager.DrawPieceHide(x, y);
}
}
Figura III.13. SetValue

32

III.3.2 Metoda OnMouseDown

În această metodă se execută evenimentul de click sau tap pe o intersecție pe care se
dorește a fi plasată piatra. Se verifică dacă este ocupată poziția, în cazul în care este ocupată
nu se mai întamplă nimic, în caz contrar s e execută mișcarea urmată de schimbarea
jucătorului

void OnMouseDown()
{
if (Value != 0) {
return;
}

bool caMove = BoardManager.Check(x, y, BoardManager.Player);
print(caMove.ToString());
if (caMove)
{
BoardManager.Move(x, y, BoardManager.Player);
BoardManager.PostMove();

if (BoardManager.Player == 1)
{
BoardManager.Player = 2;
}
else
{
BoardManager.Player = 1;
}
}
}
Figura III.14. OnMouseDown

33

Capitolul IV. Programarea jocului din punct de vedere al interfeței în Unity

IV.1 Introducere în Unity
Unity este un motor de jocuri cu platforme dezvoltate de Unity Technologies,
utilizat în principal pentru dezvoltarea de jocuri video și simulări pentru computere, console și
dispozitive mobile. Mai întâi anunțat doar pentru OS X, la Conferința Mondială a
dezvoltato rilor din 2005, Apple a fost extins până în prezent la 27 de platform e, [24], [19].
Unity aduce cu el 3 limbaje de programare (Unity Javascript, C# și Boo), un mediu
de lucru în 3D foarte similar cu Maya (de ex. camere, ferestre, interfața în general sau
conceptul de lucru) dar și capabilități de export pentru diverse medii , de la Windows și Mac
până la IPhon e, Android sau Unity Web Player, [24].
Cu Unity se pot realiza toate tipurile de jocuri, pornind de la jocuri simple 2D (care
însă sunt un 3D filmat din lateral și unde animațiile personajelor sunt, în principal, realizate în
3D) până la jocuri complexe gen: shootere sau simulatoare. Este deja la versiunea 3 și are în
spate o comunitate destul de mare de oameni do rnici să te ajute la nevoie , [21].
În creearea jocului meu am folosit scene, butone, panel -uri, scrollbar, texturi de
materiale și altele.
Creeare unei scene , [13] : Scena conține obiectele jocului, ele pot fi folosite s ă creeze
meniul, niveluri de joc și orice altceva. O scenă goală va conține o camer ă și o lumină. (Se
poate vedea in figura de mai jos, Figura IV.1) , [18].

Figura IV.1. Scena inițială din Unity

34

Figura IV.2. Crearea unei scene în Unity

Figura IV.3 . Fereast ra implicită în Unity

35
GameObjects: este unul dintre cele mai importante concepete în editorul Unity. Fiecare obiect
din joc este un GameObject. El nu poate să facă nimic singur, trebuie să primească proprietăți
înainte să devin ă un caracter, un meniu sau un efect special. [14].

Figura IV.4 . Un simplu GameObject

Figura IV.5 . GameObject

Figura IV.6 . Schema ce prezintă cele 5 obiecte ce derivă dintr -un GameObject

36
Scripturile , [15] : În jocuri, scripturile au o importanță foarte mare. Până și cel mai
simplu joc are nevoie de scripturi. Ele pot fi folosite pentru a crea efecte grafice,de
comandă,comportamentul fizic de obiecte sau chiar punerea în aplicare a unui sistem pe ntru
caracterele din joc, [18]. (Un exemplu de script se poate vedea in figura de mai jos, Figura
IV.7)

Figura IV.7 . Script [12].

Un script reușește să facă legătura cu funcționarea internă a platformei Unity prin
implementarea unei clase ce derivă din clasa încorporată, numită “MonoBehaviour” . O clasă
poate fi privită ca și un plan pentru crearea unei noi component e care să fie atașată unui
GameObject. Deci, dacă reprezintă doar un plan, codul său nu poate fi activat până când o
instanță a scriptului nu este atașată de un GameObject , [12].
Odată atașa t, scriptul va incepe să funcționeze la apăsarea butonului “Play” . Se poate
verifica prin adaugarea următorului cod î n funcția de Start:

// Use this for initialization
void Start () {
Debug.Log("I am alive!");
}

37

IV.2. Scena MenuScene

În această scenă intrăm în meniul jocului, putem alege să începem un joc nou, să citim
regulile jocului sau să ieșim afară din joc ( reprezentată în Figura IV. 8 de mai jos).
Butoanele sunt puse pe un panel pe care am pus o textură de lemn, legătura din tre
butoane și scenele la care ne duc se face prin încărcarea scenei unde dorim să ajungem.
Butonul “Exit” va închide aplicația.

Figura IV.8 . Scena Meniu

IV.3. Scena Rules

În această scenă avem explicate regulile jocului, (Figura IV.9) cum se joacă jocul dar
de asemenea și cum se calculează scorul final. Pentru afișarea textului am folosit „Scroll
View” care poate fi ultilizat atunci când conținutul care ocupă mult spațiu trebuie să fie afișat
într-o zonă mică. Astfel „Scro ll View” oferă funcționalitate a pentru a se derula conținutul,
[16].

38

Figura IV.9 . Regulile Jocului

IV.4. Scena LevelSelector
În această scenă putem alege dimensiunile tablei de joc care poate fi de 5, 7 și 9
coloane și linii. Daca alegem numărul 5, tabla de joc va avea 5 lini i și 5 coloane, dacă alegem
numărul 7, tabla de joc va avea 7 lini i și 7 coloane și dacă alegem numărul 9, tabla de joc va
avea 9 linii și 9 coloane, așa cum se poate observa în Figura IV.10.

Figura IV.10 . Selectarea nivelului

39

IV.5. Scena BoardGame Plane

În acestă scenă avem jocul propriu zis, astfel pe un panou avem așezate tabla de joc,
punctajul jucătorului cu numarul 1 dar și punctajul jucătorului cu numărul 2, butonul de
”PASS” car e la apăsarea consecutivă a jucă torului cu numărul unu și mai apoi a jucătorului cu
numărul doi, jocul se încheie urmâ nd să se ca lculeze scorul. La apăsarea butonului
”RESIGN”, cel care a apăsat butonul se consideră abandon și jucătorul celălalt câstigă partida
de joc.
La apăsarea butonului ”MENU” se va ieși din joc deschizându -se scena meniului.
La apăsarea butonului ”LEVELS” se va putea selecta din nou nivelul la care cei doi
jucători doresc să joace.
Pentru a ieși afară din joc, se va apăsa pe butonul ”MENU” și mai apoi pe butonul
”EXIT”. (Se poate observa mai bine i n figura de mai jos, Figura IV.11 )

Figura IV. 11. Tabla de joc

40

IV.6. Game Over

În aceasă scenă (Figura IV.12) se afișează în funcție de punctajul final, care dintre cei
doi jucători au câștigat meciul.
În acestă scenă am folosit:
a) Un buton cu textul ”NEW GAME” care ne va trimite la un joc nou.
b) Am folosit Text(1) și Te xtWinner pentru afișarea corectă a câștigătorului.
c) Textul ”WINS”.
d) Tex tul care afișează scorul fiecarui jucător
e) Pe fiecare text și pe buton am pus un Font pe nume „Karate”

Figura IV. 12. Meniul ce prezintă finalul jocului

Când ambele părți sunt sigure că nu se mai poate face nimic prin continuarea jocului , atunci
ambii jucători (alb și negru) apasă butonul “pass” și jocul se termină . Dacă “Player 2” apas ă
de două ori “pass” , rămânând fără posibilități de mutare, jocul se termină în favoarea celuilalt
jucător care are mai multe puncte (Player 1).

41

Concluzii

Unity oferă utilizatorilor s ăi posibilitatea de a crea jocuri atât în 2D cât și în 3D, iar
motorul oferă un API primar de scripting în C# atât pentru editorul Unity sub formă de
plugin -uri și jocuri în sine, cât și funcționalitate de tragere și plasare. C# este limbajul de
programare primar utilizat. Unity permite dezvoltarea unui joc pe multe platforme populare
într-un timp scurt.
Un alt avantaj este faptul că datorită conceptelor de care dă dovadă și a modului în care
platforma Unity este concepută am putut beneficia de un ajutor suplimentar aș putea spune
datorită secțiunii Asset Store de unde se pot implementa diferite elemente grafice, scripturi și
utilitare. Pe lângă secțiunea de atașamente platforma mai beneficiază și de foarte multe
tutoriale și documentații explicate într-un mod simplist și nu foarte complicat care mi -au fost
de mare ajutor în realizarea aplicației.
În primele capitole am prezentat tehnologiile folosite în dezvoltarea aplicației, C# este un
limbaj de programare la nivel înalt, care permite dezvol tatorilor să intre cu ușurință în
procesul de dezvoltare a jocului. Este important pentru că, spre deosebire de alte motoare de
joc bazate pe C++, C # are multe elemente și tehnici deja introduse. Tot ce rămâne de făcut e
ca dezvoltatorii să le folosească. Aceste tehnologii au făcut posibilă dezvoltarea unei aplicații
dinamice, făcând posibilă trecerea jocului GO dintr -un joc cu pietre pe o tablă, intr -o cu totul
altă lume, una nouă, diferită, digitală.
În partea a doua a lucrării am prezentat jocul propriu -zis, împreună cu s creenshot -uri la
fiecare scenă, și la reguli . Jocul este unul foarte captivant și complex in același timp .
Deci, aș putea spune că. din punctul meu de vedere , tema jocului “GO” este una
interesantă și provocatoare în acelaș i timp, iar realizarea acesteia în motorul grafic Unity 3D a
fost o alegere inspir ată.
Avantajele aplicației constau în fap tul că aceasta se pornește în câ teva secunde fără a fi
nevoie de a selecta anumiți parametri, nu necesită resurse performante, s unetul de fundal este
unul calm . culorile folosite sunt natural e (alb, negru) , cu contrast e obișnuite și nu obosesc
ochii utilizatorilor .
Îmbunătățirile care s -ar putea aduce ar fi posibilitatea jucării în rețea (Player 1 și Player 2)
în mod LAN sau într-o rețea WAN cu mai mult de 2 jucători, astfel s -ar putea organiza
campionate locale sau chiar globale de “GO” și pe alte platforme nu doar desktop, cum ar fi
pe mobil, acest joc rulând și pe Android și pe IOS. Aplicația poate fi îmbunătățită în cadr ul
elaborării lucrării de disertație, în momentul finalizării studiilor de master .

42
Bibliografie

[1]. Old Chelsea StaLion, “Noțiunile de bază ale jocului oriental de Go ” Editor: New York,
[2]. Herbert Schildt, “C#: A Beginner’s Guide ”, (2001)
[3]. https://ro.wikipedia.org/wiki/C_sharp
[4]. Gheorghe Păun, “Inițiere în Go ”, Ed. Tehnică, 1985
[5]. Kato Masao, “Go – tehnici de joc ”, Ed. Tehnică, 2000
[6]. Mirel Florescu, “Primii pași în GO” , Ed. Tehnică, 2010
[7]. Gheorghe Păun, “Printre frații mai mici ai Go -ului” , Ed. Limes, 2010
[8]. https://frgo.ro/
[9]. https://ro.wikipedia.org/wiki/Go_(joc)
[10]. http://documents.tips/documents/programare -c-55a0cdbdb2d5a.html
[11]. http://www.smart -classroom.ro/publicCourses/60/show
[12]. https://docs.unity3d.com/Manual/ScriptingSection.html
[13]. https://docs.unity3d.com/Manual/UISystem.html
[14]. https://docs.unity3d.com/Manual/UNetSceneObjects.html
[15]. https://docs.unity3d.com/Manual/script -ScrollRect.html
[16]. https://brainking.com/ro/GameRules?tp=79 ]
[17]. https://www.javatpoint.com/csharp -features
[18]. https://docs.unity3d.com/Manual/CreatingAndUsingScripts.html
[19]. Ovidiu Constantin Novac – “Sisteme multimedia” ( materialul de curs)
[20].https://books.google.ro/books?id=Y5UeBT0L0MsC&printsec=frontcover&d q=go+game
+capture+stones&hl=en&sa=X&ved=0ahUKEwi8rfH_66HdAhUQfFAKHfZSCRAQ6AEIK
DAA#v=onepage&q=go%20game%20capture%20stones&f=false
[21]. https://www.red -gate.com/simple -talk/dotnet/c -programming/introduction -game –
development -unity -c/
[22]. https://ro.wikipedia.org/wiki/C_(limbaj_de_programare)
[23.] http://software.ucv.ro/~mburicea/Cap4POO.htm
[24]. https://en.wikipedia.org/wiki/Unity_(game_engine)
[25]. Cornelia Gyorodi – Programarea calculatoarelor și limbaje de programare –
https://www.scr ibd.com/document/122585602/Programare -C

43
[26]. D. Zaharie, Doina Zmaranda, Dezvoltarea aplicațiilor software utilizând platforma
.NET, Editura ASE, ISBN 978 -606-505-547-6, 2012
[27]. Doina Zmaranda, Elemente de programare orientată pe obiecte în limbajul C # – Editura
Universității din Oradea, ISBN 978 -973-759-522-5, 2008
[28]. Doina Zmaranda, Programare orientată pe obiecte cu aplicații în Visual C++, Editura
Universității din Oradea, ISBN 973 -613-681-7, 2004
[29]. Doina Zmaranda, Elemente de programare o rientată pe obiecte utilizând limbajul C++,
Editura Universității din Oradea, ISBN 973 -613-013-4, 2001