PROGRAMUL DE STUDIU TEHNOLOGIA INFORMAȚIEI [617332]

UNIVERSITATEA DIN ORADEA
FACULTATEA DE INGINERIE ELECTRICĂ ȘI TECHNOLOGIA INFORMAȚIEI
PROGRAMUL DE STUDIU TEHNOLOGIA INFORMAȚIEI
FORMA DE ÎNVĂȚĂMÂNT IF
JOC DE ACȚIUNE INTERACTIV ÎN LIMBAJUL DE
PROGRAMARE JAV A
COORDONATOR ȘTIINȚIFIC
Conf.dr.ing. Gianina GABOR
ABSOLVENT: [anonimizat]
2018
1

Cuprins
INTRODUCERE…………………………………………………………………………………………………………….. 3
CAPITOLUL 1. TEHNOLIGII UTILIZATE LA IMPLEMENTAREA APLICAȚIEI ……………………………….. 5
1.1 JavaFX…………………………………………………………………………………………………………………… 5
1.2 Modelul model-view-controller(MVC) ………………………………………………………………………. 7
1.3 Apache Maven ……………………………………………………………………………………………………….. 9
1.4 MySQL………………………………………………………………………………………………………………… 10
CAPITOLUL 2 . ANALIZA ȘI DESCRIEREA CONTEXTULUI APLICAȚIEI ……………………………………. 11
2.1 Pornirea unui nou joc ……………………………………………………………………………………………. 11
2.2 Jocul principal………………………………………………………………………………………………………. 12
2.3 Meniul Game Over ……………………………………………………………………………………………….. 14
CAPITOLUL 3. IMPLEMENTAREA APLICAȚIEI …………………………………………………………………… 15
3.1 Controlarea personajului din joc …………………………………………………………………………….. 15
3.2 Armele din joc……………………………………………………………………………………………………… 16
3.3 Articolele de prim ajutor din joc …………………………………………………………………………….. 18
3.4 Sistemul de desenare din joc …………………………………………………………………………………. 19
3.5 Sistemul de importare al imaginilor ………………………………………………………………………… 21
3.6 Personajul din joc …………………………………………………………………………………………………. 23
3.7 Zombi din joc……………………………………………………………………………………………………….. 25
3.8 Implementarea bazei de date ………………………………………………………………………………… 26
3.9 Implemetarea Mavenului ………………………………………………………………………………………. 31
CONCLUZII………………………………………………………………………………………………………………… 32
BIBLIOGRAFIE……………………………………………………………………………………………………………. 33
2

INTRODUCERE
Jocurile video sunt o formă al divertismentului care au avut un început în anii '70 după
ce tehnologia a început să se dezvolte. Dacă atunci jocurile au fost doar în fază de
experimentare în zilele noastre jocurile video fac parte dintr-o mare industrie. Azi putem zice
ca suntem în deceniul cinci al jocurilor video. Cel mai mare pas în industrie l-a reprezentat
realizarea primelor jocuri în totalitate 3D, introducerea conceptului de cloud gaming și
creșterea popularității jocurilor pe tablete și telefoane.
Ultimele două generații de jocuri sunt reprezentate de generația șase și șapte. Cu
generația a șaptea si cu ajutorul unui salt în tehnologie au aparut jocurile de tip Role-Playing
Game(RPG) și First-Person Shooter(FPS). În generația a șaptea din cauza crizei economice
producerea consolelor de jocuri video și a jocurilor însuși a devenit mult mai costisitoare
astfel încât consolele de jocuri și jocurile au devenit mult mai scumpe și pentru o perioadă de
vreme destul de îndelungată jocurile de video au fost considerate echipamente de lux. Din
aceasta cauză tipurile de jocuri care au devenit populare înainte de generația a 7-a au început
sa intre în declin și au început să crească în popularitate jocuri cu genuri care au fost populare
în trecut, pentru că a început să crească popularitatea dezvoltatorilor de jocuri independente
care au creat jocuri mai personalizate astfel noile categorii de jocuri au devenit unice.
Programarea jocurilor video face parte din ingineria programării, un joc video fiind
alcătuit din mai multe părți ce trebuie realizate pentru a avea un produs final complet, care
implică crearea modelelor folosite în joc sau a codului propriu pentru funcționarea corectă a
jocului. În ultimii ani jocurile video care au alocat un buget foarte mare și un timp de
dezvoltare mai îndelungat au fost dezvoltate utilizând limbajul de programare C sau limbajul
C++.
O explicație pentru această decizie o reprezinta faptul că pentru consolele de jocuri
care au de obicei hardware special creat, acesta e diferit de al unui computer desktop. Jocul
trebuie programat ținând cont de faptul că memoria și ciclurile de CPU trebuie utilizate astfel
încât jocul să funcționeze folosind aceste resurse în mod optim. O altă explicație o reprezintă
faptul că atât C cât și C++ sunt învățate în școli și universități, sunt folosite pe piața de IT
deci limbajele de programare sunt cunoscute pe scară largă și sunt folosite și pentru
creare/implementare de jocuri. Ultimele versiuni de jocuri utilizeaza inclusiv tehnologia C#.
3

Pentru crearea graficii jocurilor video de obieci sunt folosite motoare grafice
proprietare deci create special de fiecare dezvoltator de joc. Dezvoltatorii independenți de
obicei folosesc limbaje de programare care le sunt utile sau sunt disponibile. Pentru
implementare motorul de joc de obicei se folosesc motoare care sunt disponibile publicului
contra cost sau gratis.
Deși limbajul de programare Java nu este un limbaj de programare foarte popular și
foarte mult folosit în domeniul creării jocurilor video totuși sunt exemple de astfel de jocuri
create, jocuri foarte populare și foarte reușite, cum ar fi: Minecraft, Runescape, Vampire: The
Masquerade – Redemption.
Limbajul de programare Java este un limbaj de programare orientat pe obiecte, deci
este capabil să rezolve probleme similare cu alte limbaje de programare orientate pe obiecte
cum ar fi C++ sau C# care sunt mult mai frecvent utilizate în domeniul jocurilor video, de
aceea am ales să implementez un joc în limbajul de programare Java.
Jocul implementat are ca tematică lupta dintre un personaj principal (eroul principal)
si un număr mare de adversari (personaje tip zombi) pe care trebuie sa îi învingă până la
final. Personajele de tip zombi sunt în număr mai mare decât personajul nostru deci personajul
principal este întrun mare dezavantaj. Ca să supraviețuiască este ajutat de un număr de
instrumente prezente în joc cu care personajul principal poate să se apere. Dacă se consideră
tematica jocului implementat în cadrul lucrării de diploma, acesta se încadrează în tip ul de
joc top down shooter, joc care a fost popular în trecut, dar datorită dezvoltatorilor
independentți începe să își regăsească audiența.

4

CAPITOLUL 1. TEHNOLIGII UTILIZATE LA IMPLEMENTAREA
APLICAȚIEI
1.1 JavaFX
JavaFX este un set de pachete grafice și media care permite dezvoltatorilor să
proiecteze, testeze, depaneze si să ruleze aplicații de tip client care pot să funcționeze pe
diferite platforme. Librăria JavaFX este scrisă ca un API() Java deci codurile aplicațiilor
implementate în JavaF X pot să facă referire la celelalte API-uri din alte librării Java. De
exemplu aplicațiile JavaFX pot să folosească librării API pentru a folosi capabilitățiile native
al sistemului și de a conecta la o aplicație middleware de tip server.
Apariția aplicației JavaFX poate să fie personalizată cu ajutorul lui Cascading Style
Sheets (CSS).[1]
Cascading Style Sheet(CSS) separă aspectul și stilul de implementare pentru ca
dezvoltatorii să poate concentra pe cod. Se poate folosi JavaFX Scene Builder dacă vrem să
facem designul interfeței și nu vrem să folosim cod. CSS în JavaFX este aplicat nodurilor din
JavaFX scene-graph în care stilurile sunt aplicate similar de la HTML DOM. Stilurile sunt
aplicate prima dată părintelui și apoi copiilor. Codul este scris în așa fel încât numai acele
părți din scene-graph sunt verificate din nou la care trebuie reaplicate stilurile CSS. [2]
JavaFX oferă o anumită flexibilitate pentru crearea Interfeței de utilizator partea pe
care este vâzut de utilizatori poate să fie creat în limbajul de scritping FXML iar partea logică
poate să fie codat în limbajul Java, dar dacă dorim să cream interfața fără codare atunci putem
folosi o funcție al lui JavaFX numit JavaFX SceneBuilder, cum creăm interfața de utilizator
SceneBuilder-ul crează o marcare FXML care poate să fie intergrat întrun Integrated
Development Environment (IDE).
JavaFX este disponibil ca și caracterisitcă integrată în Java SE Runtime Environment
(JRE) și Java Development Kit (JDK ). Pentru că JDK-ul este disponibil în toate platformele
majore de tip desktop aplicațiile JavaFx create în versiunile JDK 7 și versiunile mai noi pot să
ruleze pe toate platforme desktop majore.
Cele mai importante caracteristici al lui JavaFX sunt:
5

Java API este o librărie care este alcătuită din clase și interfețe scrise în limbajul
Java
WebView este o componentă care folosește tehnologia WebKitHTML care face
posibilă folosirea paginilor încuibate în JavaFX. A fost instalat ca suport adițional
pentru folosirea unor funcții HTML5- WebSocketuri și WebWorkers
Funcțiile Swing pot fi upgradate cu funcții JavaFX
Grafică 3D care implementează clase pentru crearea diferitelor forme 3D
Canvas API care permite desenarea în mod direct pe o scenă creată de JavaFX
API de printare care permite lucrul direct cu API-ul JavaFX Printing
Model de desfășurare de aplicații independente – pachete ale aplicațiilor
independente au toate resuresele aplicațiilor și o copie privată a runtime-urilor de
la Java și JavaFX, fiind distribuite ca pachete ce pot fi instalate. [1]
Clasa Application din JavaFX furnizează un framework pentru aplicațiile care o
folosesc. Runtime-ul JavaFX are un ciclu care se execută de fiecare dată când o aplicație
folosește clasa Application, din cauza asta nu este o practică bună de a nu folosi JavaFX după
ce toolkit-ul JavaFX a fost închis și a ajuns la finalul ciclului.
Când se crează o aplicație aceasta este creată întrun thread. În thread rebuie s ă fie
inițializate și obiectele JavaFX Scene și Stage. Excepții pot să apară când apar evenimentele,
când sunt executate animațiile sau în orice altă parte al codului, dacă se întâmpla așa ceva
atunci acesta este trimis la interfața numită manipulatorul de excepții. [3]
Clasa Scene este recipientul pentru tot conținutul aflat în scene graph care este o
arboră de structuri de date care are abilitatea de a ști la fiecare pas ce obiecte să fie afișate, ce
părți al ecraneului trebuie reparat și cum trebuie interpretat în cel mai eficient mod . Fundalul
este pus cu ajutorul proprietății fill. Mărimea scenei este inițializat de aplicație la construcție,
dacă nu sunt date mărimi inițiale atunci se vor crea cu mărimile implicite. Mărimile implicite
sunt calculate pe baza mărimilor preferate ale conținuturilor. Dacă numai o singură mărime
este dată atunci celelalte mărimi vor fi calculate pe baza primei mărimi. Aplicația trebuie să
specifice nodul rădăcină pentru grafica de scenă. Dacă se dorește să se creeze obiecte 3D
atunci trebuie utilizate buffere de adâncime și support pentru anti-aliasing.
Un buffer de adâncime este folosit pentru a interpreta pe bază de adâncime întrun mod
corect, pentru a evita lupta de adâncimi. Prin suport pentru anti-aliasing înțelegem acordul de
6

a permite aplicației de a folosi anti-aliasing care are rolul de a creșterea calității le grafici
acestuia [4]
Clasa Stage este nivelul cel mai superior când vorbim despre recepiente JavaFX. Când
vorbim despre recepiente JavaFX ne referim la acele clase cu care putem să modificăm
apariția ferestrei aplicației și a componentelor aflate în fereastră. Etapa primară este construită
de platformă, apoi putem să construim etape adiționale care sunt implementate de aplicație.
Fiecare obiect de tip e tapă trebuie să fie executată întrun thread. Etapa are mai multe stiluri pe
care putem să le aplicăm. O etapă poate să aibă o fereastră proprietar deci spunem că acesta
este părintele, dacă acesta este închis atunci toate descendentele lui vor fi închise. [5]
1.2 Modelul model-view-controller(MVC)
Modelul MVC este un model arhitectural care este în mare parte utilizat pentru crearea
unor interfețe grafice pentru utilizatori. Premisa principală al modelului este bazată pe
modularitatea și abilitatea de a crea trei aspecte diferite ale interfeței grafice : data (model),
reprezentarea vizuală al datei (view), interfața dintre view și model (controller). Idea
principală este de a avea aceste trei c omponente separate una de cealaltă pentru a avea
independență, de aceea dacă se va face o modificare la una dintre aceste componente celălalte
nu vor fi afectate. Cel mai mare avantaj al acestei model îl reprezintă abilitatea de a reutiliza
logica aplicației când vrem să implementăm o altă aplicație.
În general modelul este implemetat prima dată. Acest model are două sarcini
importante, prima este salvarea stări lor și a doua sarcină este genstionarea abonaților prezente
în model. Starea nu trebuie să fie ceva foarte complex trebuie doar să decidem cum vrem să
depozităm detele. Proprietățile trebuie să fie asociate unor listeneri care sunt grupați întro
listă, proprietățile vor contacta această listă dacă se vor schimba . Codul poate să fie definit
într-o superclasă care apoi poate să fie moștenită de proprietățiile create, deci acesta trebuie
scrisă numai întrun singur loc. Un bun model MVC are grijă de superclasă și abonații
modelului astfel încât cel mai mult efort să fie pus pe codare.
Când modelul de date a fost finalizat de obicei este creat modelul view ca pas
următor. View-ul este componenta care este în direct conexiune cu un model. De obicei acesta
este afișat unor useri prin intermediul unei interfețe de user. Mai pot să facem modele
controller-view care nu ai nimic de a face cu interfețe de utilizatori. Când creăm un view
7

probleme la care trebuie să gândim este cum să reacționăm când apar schimbări la stări și cum
să afișăm informațiile utilizatorilor. Cu cât mai complex sunt proprietățiile folosite cu atât mai
complex editori și mai complexe view-uri sunt necesare, dar frameworkul știe deja cum
trebuie conectate aceste componente la model și poate să autoconfigureze componenetele
bazate pe prorietăți.
Pentru părțile care nu se schimbă când modelul se schimbă ține de responsabilitatea
controller-ului. Acesta trebuie să ajută la navigarea în view și știe cum să răspundă la
schimbările în view. Viewul nu poate fi modificat și poate fi folosit numai în mod de citire,
deci când dorim/ trebuie să modificăm ceva în view atunci controler-ul răspunde eventul de
editare, și este cel care îl pro cesează și îl trimite modelului care va face modificările
corespunzătoare ale valorilor. Controler-ul poate fi implementat în diferite moduri, fie prin
funcții de callback care sunt asociate cu diferite editori care sunt utilizate când se schimbă
valorile fie prin adăugarea de ascultători în mod direct în component e care pot fi notificate
când valorile se schimbă în editoare.
Când este posibil cea mai bună metodă ce poate fi utilizată este cea care lasă modelul
să facă validările necesare asupra valorilor astfel încât toate schimbările valorilor sau
schimbări ale procesului de validare să fie făcute doar într-o singură locație. Dar se poate
întâmpla ca acestă metodă să nu poată fi utilizată, de exemplu se poate întâmpla ca o valoare
numerică să fie modificată și vream să o trimitem la controler dar acesta este transmisă printr-
o valoare text deci trebuie creată o altă metodă pentru transformarea valorilor.
În aplicația implementată conceptul MVC este implementat pentru că ajută la
implementarea logicii programului, și mai ajută la distribuirea sarcinilor programului. Ca și la
explicația generală a conceptului programul implementează cele trei aspecte ale acestuia:
modelul, controler-ul și view-ul. [6]
Pentru a implementa aceste aspecte în program au fost create trei pachete diferite care
sunt numite controller, model și view care conțin diferite clase, interfețe sau date de tip enum.
În pachetul controler există o singură clasă numită GameController.java care conține diferite
funcții care controlează evenimentele legate de apăsarea tastelor și cele legate de mouse.
Rolul cel mai important al controler-ului din program este de a face disponibile funcții care
pot fi folosite de diferite clase din model pe pot fi ulterior modificate sau suprascrise deci
clasa poate să decide cum să folosească aceste funcții.
8

Pachetul model are ca și conținut diferite clase care execută acțiuni diverse. Aceste
clase pot fi ca și clasa Player.java care are funcții care decid ce să se întâmple când se apasă o
tastă sau când mouse-ul este folosit respectiv ca și clasa GameSprite.java care conține funcții
care manipulează valori și variabile sau le returnează pentru a lucra cu imagini pe care vor fi
desenate. Cele mai multe clase sunt clase care lucrează cu obiecte.
În pachetul view există clasa GameWindow.java care are un rol important și anume de
a desena imaginile corespunzătoare obiectelor prezente în joc și de a crea și furniza toate
elementele necesare pentru a putea desena toate imaginile obiectelor.
1.3 Apache Maven
Apache Maven este un sistem de build, mangement de proiect are și un container
abstract pentru rularea task-urilor. Acest sistem cuprinde un model care conține un obiect de
tip proiect, un set de standarde, un ciclu de viață al proiectului, un sistem pentru
managementul dependențelor și o logică pentru executatea scopurilor plugin-urilor definite în
diferite puncte ale ciclului de viață al proiectului. Când folosim Maven descriem proiectul cu
un model de tip proiect după care putem aplica o logică transversală dintr-un set de plugin-uri.
Înainte ca Maven s ă fie folosit într-o scară mai largă de multe ori fieacare proiect în
parte avea un sau mai multe persoane dedicate cu scopul de creare și de mentenanța unor
sisteme build personalizate.
Cu ajutorul lui Maven se pot crea interfețe comune pentru proiecte. Maven
implementeză conceptul de Convention Over Configuration care înseamnă că fără schimbări
în codul sursă, resursele, testele, au o locație predefinită iar proiectul produce un JAR
executabil, deci nu trebuie să predefinim localizarea acestora. Acesta este una dintre cele mai
folositoare caracteristici Maven și anume faptul că putem să folosim convențiile implicite dar
putem opta pentru personalizarea tuturor opțiunilor.
Dar funcția de Convention Over Configuration poate să fie folosit nu numai pentru
ușurarea pentru lucrul cu locațiile, de exemplu pluginurile oferă un set de convenții pentru
compilarea codurilor sursă. Convention Over Configuration are un ciclu de viață bine definit.
Instalarea programului Maven este o procedură relativ simplu. În sistemele de operare
Linux și MAC OSX trebuie descărcat versiunea binară de pe websiteul oficial și trebuie
instalat și ca un ultim pas trebuie pus directorul în calea de comandă.
9

Instalarea prgramului Maven pe sistemul de operare Windows este similar ca și
instalarea pe sistemele de operare Linux și MAC OSX cu diferența că calea implicit pentru
instalare va fi dat pe partițiunea de disk unde este instalat sistemul de operare iar apoi trebuie
configurat variabila de enviornment numit PATH.
În Maven proiectele, buildurile, dependențele sunt obiecte care trebuie modelate și
descrise. Aceste obiecte sunt descrise de un fișier tip XML numit Project Object Model. POM
spune Mavenului ce fel de project este și cum trebuie să se facă schimbări la setările implicite
încăt să se producă rezultatele dorite. [7]
1.4 MySQL
MySQL este un sistem de menegment al bazelor de date folosind SQL.
SQL(Strucutred Qqery Language) este cel mai folosit și standardizat folosit la
accesarea bazelor de date. Depinzând de mediul în care lucrăm putem să lucrăm cu SQL
direct sau putem să scriem SQL împreună cu un limbaj de programare.
Bazele de date relaționale din MySQL sunt depozitate în tabele separate mai degrabă
într-o singură locație. Modelele logice ca și bazele de date, tabelel oferă o flexibiliatate la
mediul de programamre aleasă. Putem să creăm regurile de relații între tabelel create de
exemplu relația de unu-la-unu.
MySQL Database Software este un sistem de client/server care este alcătuit dintrun
SQL Server de multi-threading care suportă diferite backend-uri, diferite programe de client și
librării.[8]
MySQL Workbench este un instrument grafic pentru lucrul cu serverele și bazele de
date MySQL. MySQL Workbench permite crearea conexiunilor la baza de date, administrarea
bazelor de date și migrarea datlor din baza de date. [9]
10

CAPITOLUL 2 . ANALIZA ȘI DESCRIEREA CONTEXTULUI APLI –
CAȚIEI
2.1 Pornirea unui nou joc
Când pornim jocul apare ecranul jocului cu o fereastră în interiorul lui care o să fie
meniul principal al jocului, în acest fereastră apare numele jocului care este ‘ Zombie Hunter’
și un buton verde în care se va scrie START GAME, aceasta se va numii meniul principal al
jocului.
Fig. 2.1. Meniul principal
Pentru a începe un joc nou trebuie dat click dreapta în interiorul butonului STAR
GAME și se va începe un joc nou.
Meniul principal a fost creat întrun manieră stilistic minimalist pentru ca jucătorii să
poate înțeleagă clar cum să se inițializeze un joc nou.
11

2.2 Jocul principal
Principala țintă al jocului este de a supraviețui cât mai mult și de a omoră cât mai
multe inamici din joc care sunt zombi. Pentru că aceste două lucruri sunt importante pentru
joc sunt afișate în mod constant în joc.
Timpul supraviețiut este reprezentat printrun ceas afișat în colțul stâng sus, iar
numărul zombilor omorăți este reprezentat prin afișarea textului ‘ Zombies killed:’ urmat de
numărul de zombi omorăță este afișat tot în colțul stâng lângă ceas.
Fig. 2.2. Ceasul și numărul zombiilor omorăți
Jucătorul este reprezentat în joc prin personajul pe care o controlează. Acest personaj
este reprezentat în joc printrun om militar.
Personajul poate să fie controlat prin tastatură cu tastele W,A,S,D, apăsând aceste
tastaturi personajul va începe să miște la direcția tastei apăsate sus, jos ,stânga sau dreapta.
Personajul mai trebuie controlat prin mișcarea și apăsarea butonului stâng al mouseului. Prin
mișcarea mouseului personajul va mișca spre direcția cursorului mouseului și dacă apăsăm
butonul stâng al mouseului atunci personajul va ataca.

Fig. 2.3. Personajul din joc
Personajul din joc mai are o bară de viață care reprezintă câte atacuri poate personajul
să susțină. Acesta este reprezintat printrun dreptunghi de culoare verde pe poziția de colțul
dreapt sus al ecranului. Dacă personajul a fost atăcat cu succes de zombi atunci va pierde din
viața lui totală. Dacă viața personjului ajunge la zero atunci jocul a luat sfârșit.
12

Fig. 2.4. Bara de viață al personajului
Inamicul din joc este reprezentat prin zombi. Zombi din joc au un scop numai în joc ,
și scopul este de a ataca personajul.
Când zombii apar în joc atunci ei vor înepe să fugă spre personaj și când sunt în
aproprierea personajului atunci vor începe să-l atacă. Zombi nu vor înceta să urmărească pe
personaj și să-l atace numai dacă au fost omorăți.
Fig. 2.5. Zombi din joc
Pentru ca personajul poate să se apare pe jos sunt plasate diferite arme cu care
personajul poate să atace. Pentru a ridica aceste arme trebuie numai să facem o coliziune cu
el. Armele sunt repreznetate printr-o strălucire de culoarea albastră pentru a putea fi
identificate mai ușor. Pentru a ataca cu o armă jucătorul trebuie să apase butonul stâng al
mouseului. Sunt patru tipuri de arme în joc și fiecare este un pic diferit față de alta.
Fig.2.6. Armă prezent în joc
13

În joc există sistemul de a recupera viața al personajului. Acesta poate să fie făcut prin
folosirea a unor articole de prim ajutor. Ca și armele aceste articole sunt pe jos și pot fi
ridicate ca și armele. Există patru tipuri de articole fiecare recuperă a sumă diferită la viață.
Articolele de primul ajutor sunt reprezentate în joc de o strălucire de culoarea verde
pentru a putea fi diferenciat în joc.
Dacă vream să folosim un articol atunci trebuie să apasăm butonul stâng al mouseului
și atunci viața fi recuperată.
Fig.2.7. Articol de prim ajutor din joc
Când facem coliziune cu armele sau articolele de prim ajutor pentru a le ridica atunci
aceste vor fi puse înrtun inventar care este reprezentat prin patru dreptungiuri albe care sunt
puse la partea jos al colțului stâng, deci în inventar pot să fie prezent numai patru arme sau
articole de prim ajutor în același timp.
Prin inventar putem să schimbăm care armă sau articol de prim ajutor vream să
folosim. Pentru a schimba dintre aceste trebuie apăsat tastele 1,2,3,4 pe tastatură, fiecare tastă
reprezintă o poziție în inventar.
Fig.2.8. Inventarul din joc
14

2.3 Meniul Game Over
Când viața personajului va fi redus la zero și atunci jocul a luat sfărșit. Când se
întâmplă asta atunci va apărea meniul de game over. Acest meniu va apărea întrun dreptungi
alb cu titlul Game Over. În acest meniu vor fi afișate primele 20 de jucători cu numele lor, cât
timp au supraviețuit și câte zombi au omorât.
Dacă timpul supraviețuit sau numărul zombiilor este undeva în acele 20 de jucători
atunci jocul va cere ca jucătorul curent să introducă numele lor.
Trebuie introdus numele la poziția unde a ajuns jucătorul pe tabelă și când apăsam
tasta enter atunci datele vor fi memorate în tabel și se va începe un joc nou.
Dacă sa ajuns la ecranul de game over dar rezultatele nu sunt suficiente de a introduce
în tabelă atunci putem să începem un nou joc prin apăsarea butonului de Play Again.
Fig.2.9. Meniul de Game Over
15

CAPITOLUL 3. IMPLEMENTAREA APLICAȚIEI
3.1 Controlarea personajului din joc
Mișcarea personaljului din joc este făcută de persoana care joacă jocul în momentul
dat. Interacțiunea se va face cu tastatura împreună cu mouseul. Pentru mișcarea personajului
pe nivel persoana care jocă jocul trebuie să apasă tastele W,A,S,D care va mișca personajul pe
direcțiile sus, jos, stânga sau dreapta care depinde de tasta apăsată.
Dacă personajul nostru are arme la dispoziția lui atunci putem să atacăm zombi pe
nivel. Personajul va ataca cu arma care este selectată, pentru a ataca trebuie apăsat butonul
stâng al mouseului.
Când apăsăm unul dintre tastele W,A,S,D sau când apăsăm butonul stâng al mouseului
atunci o serie de evenimete vor fi parcurse. A fost creat o interfață numită
GameEventHandler.java în care sunt declarate metodele corespunzătoare pentru apăsarea
tastaturilor și pentru apăsarea butoanelor al mouseului și care va prinde aceste evenimente
care vor fi transmise clasei care va implementa interfața.
Acest interfață este implementat de clasa GameController.java care va prinde tastele
apăsate al tastaturi și butoanele apăsate al mouseului și le va stoca și va trimite aceste
informații mai departe printr-o metodă care va fi aplicat în fiecare ciclu.
Metoda câtre care va fi transferat informațiile mai departe se numește
GameRoom.java care are rolul de a transfera informațiile primite de la GameController.java
tuturor obiectelor prezente în joc în momentul aplicării metodei care se va aplica la fiecare
ciclu.
După ce fiecare obiect din joc primește informațiile în legătură cu tastele și butoanele
apăsate este treaba fiecărui obiect în parte de a decide ce acțiune să ia dacă primește aceste
informații, în cazul nostru numai personajul din joc va ia acțiune în cazul apăsării tastelor își
va modifica poziția proprie pe baza tastei apăsate. La apăsarea butonului stâng al mouseului
pe baza armei curente personajul va putea ataca.
16

3.2 Armele din joc
Pentru a înfrânge zombi personajul are nevoie de arme. Aceste arme sunt dispersate în
diferite locații pe nivel, iar pentru a putea folosii aceste arme trebuie să fie strânse de
personaj. Pentru implementarea acestor arme a fost creat un package separat în care sunt puse
toate clasele necesare pentru a lucra cu obiectele care sunt arme în joc. În joc există patru
tipuri de arme care sunt : PISTOL,HANDGUN,SHOTGUN,KNIFE.
Pentru a implementa aceste categorii de arme a fost creat în package un enum numit
WeaponType.java în care se enumerează aceste categorii.
Fiecare armă în joc are un număr de proprietăți generale prin care se va puta
diferenția între armele din joc , acestea sunt: name, damage, durability și attackDelay.
Name descrie numele armei care va fi arătat în joc , damage descrie căt de mult va
scade din viața lui zombi dacă va fi atacat de armă, durability va descrie cât de durabil este
arma, dacă durabilitatea scade până la valoarea zero atunci arma va fi distrusă și nu mai poate
să fie folosit. AttackDelay este proprietatea care va descrie cât de des se paote ataca cu arma
selectată în momentul atacului. Pentru a implementa aceste proprietăți a fost crea o clasă nouă
numit WeaponProprierties.java, în această clasă conform tipurilor de arme menționate mai sus
se vor seta aceste proprietăți în clasă.
Dacă ne uităm la numele tipurilor de arme prezente putem să deducem că trei din cele
patru arme sunt arme care trag glonțuri și unul este care nu. Acesta este o distincție importantă
de amintit mai ales din pnctul de vedere al mecanismele jocului , pentru că un cuțit nu poate
să tragă gloanțe. Din cauza asta au fost create trei diferite clase pentru a lucra cu armele,aceste
sunt: WeaponItem.java , BallisticWeaponItem.java, MeleeWeaponItem.java.
BallisticWeaponItem.java a fost creat pentru a gestiona armele care trag glonțuri. În
această clasă armelor care trag glonțuri sunt asociate proprietățiile generale care au toate
armele dar mai are și o metodă unică care permite să creeze gloanțe când se atacă cu arma.
Glonțul va fi creat în fața personajului și va începe să miște în aceia direcție.
Glonțul este reprezentat ca un obiect în joc de clasa Bullet.java în această clasă există
două metode importante unul este un eveniment de coliziune în care se va verifica coliziuna
cu un alt obiect și dacă se întâmplă asta atunci zombi va fi lovit și va pierde din viața totală
egală cu proprietatea damage. Următorul metodă foarte importantă este o metodă care este o
altă eveniment care va fi aplicat la fiecare ciclu și la fiecare ciclu va mișca glonțul la direcția
corectă.
17

MelleWeaponItem.java a fost creat pentru a gestiona arma care nu trage glonțuri. Ca
și la clasa BalisticWeaponItem.java și clasa MeleeWeaponItem.java are toate proprietățiile
generale ale armelor și mai are mai multe metode importante. O metodă importantă este un
eveniment care va fi apelat la fiecare ciclu și va decide dacă personajul care atacă este la o
distanță acceptabilă de zombi. Distanța este calcualtă pe baza imaginilor ale obiectelor
prezente în joc. O altă metodă importantă este metoda care se va aplica în momentul care
zombi a fost lovit , această metodă resetează toate variabilele asociate cu arma curentă cum ar
fi resetarea propietății attackDelay. O altă metodă importantă care va fi aplicat atunci când se
va face coliziune cu zombi atunci metoda va scade proprietea de durability adică se va scădea
din durabilitatea totală al armei cu fiecare coliziune cu zombi și va scădea din viața totală al
lui zombi cu amănuntul total ce este reprezintat la proprietea damage.
WeaponItem.java este o clasă pe care clasele MeleeWeaponItem.java și
BallisticWeaponItem.java o extind. Acestă clasă stă la baza celor două clase și are rolul de a
asocia armele din joc cu proprietățiile corespunzătoare bazată dacă sunt MeleeWeaponItem
sau BallisiticWeaponItem. Alte roluri importante ale clasei sunt lucrul cu proprietatea
durability adică de a reduce valorii acestuia dacă a fost făcut un atac cu o armă și celălalt rol
important este lucrul cu proprietatea attackDelay, acesta va inițializa o valoare care va fi
incremenata și va fi verificat la fiecare ciclu dacă aceasta atinge valoarea curespunzătoarea
armei și dacă se va atinge acest valoare atunci se poate ataca cu arma curentă și dacă se atacă
atunci clasa va reseta această valoare și ciclul va începe din nou.
Pentru a reprezenta armele când sunt pe nivel pentru a putea fi ridicat de personaj din
joc este creat o clasă numită WeaponObject.java în acestă clasă o să se facă inițializarea
obiectelor cu proprietățiile generale ale armelor și se va seta imaginea corespunzătoare armei.
3.3 Articolele de prim ajutor din joc
În joc pentru că inamicul este prezent întrun număr mai mare decăt personajul și de
aceia este prea ușor de a pierde în joc. Considerând acest fapt trebuie introdus o mehanică de
joc prin care personajul din joc poate recăpăta o parte din viața lui pierdută. Implemetarea
acestora vor făcute prin crearea unui enum numit HealthType.java. În acest enum se vor crea
patru tipuri de articole: SURVIVALBAR, HOTDOG ,MEAT și RATIONS, acest enum va fi
18

folosit de celălalte clase pentru a crea aceste articole diferite. Aceste articole sunt plasate pe
nivel ca și armele și trebuie ridicat ca armele.
Ca și armele și aceste articole au proprietăți ca tipurile să fie mai unice, aceste
prorietăți sunt: name și heathRegained. Proprietatea name descrie numele care va fi arătat în
joc. Prorietatea healthRegained arată cât va fi adaugat la viața curentă al personajului.
Aceste proprietăți sunt folosite de două clase diferite HealthObject.java și
HealthItem.java, fiecare dintre aceste clase folosesc aceste proprietăți pentru a inițializa aceste
articole. Clasa HeatlhObject.java extinde clasa GameObject.java deci această clasă este folosit
pentru a plasa aceste articole pe nivel, iar HealthItem.java va fi folosit când aceste sunt
folosite de personaj ca și armele curente.
3.4 Sistemul de desenare din joc
Întrun joc o parte importantă care este întotdeaunea judecate este estetica lui. De aceia
dacă un joc este din punctul de vedere al estetici minimalist totuși trebuie pus un pic de efort
în partea de estetică. Pentru că pe baza proiectului stă modelul model-view-controllel
desenarea se va face în view, pentru asta a fost creat un pachet numit view în care sunt două
clase. A fost creat o interfață numit GameView.java în care au fost declarate metode care vor
desena diferite părți din joc.
Clasa în care se vor implementa aceste metode este clasa numită GameWindow.java
pentru că această clasă implementează GameView.java. Pe baza implementării claselor stă
faptul că trebuie desenat mai multe tipuri de elemente în joc, din cauza asta în clasa
GameWindow.java au fost create clase private care sunt derivate dintrun clasă abstractă
Drawable care descrie unde va fi desenat. Toate celălalte clase vor extinde această clasă cum
ar fi clasele SpriteToDraw care are rolul de a desena imaginile corespunzătoare obiectelor la
locațiile corespunzătoare. Clasa TextToDraw are rolul de a afișa textele necesare la locul
corespunzător cu un font specific ales. Clasa RectangleToDraw are rolul de a desena
dreptunghiuri la locurile specificate cu o lățime și lungime determinat cu o culoare care va fi
dat prin crearea lui prin culorile roșu, verde, albastru fieare dintre aceste culori reprezetate în
clasă.
Sistemul de desenare este creată în așa fel încăt va desena diferitele elemente în
diferite faze al execuției lui, așa putem controla mai bine când și cum vor fi desenate
19

elementele. Pentru asta au fost create metode diferite în GameView.java care vor fi
implementate în GameWindow.java aceste două clase sunt PreDrawEvent și PostDrawEvent.
Metoda PreDrawEvent are rolul de a desena fundalul pe nivel, se va inițializa
imaginea aleasă al fundalului și aceste imagini vor fi plasate pe toate cele patru colțuri ale
nivelului iar apoi va fi plasat pe toate supratața nivelului prin plasarea în mod treptat pe
părțiile de sus , jos , stânga și dreapta al nivelului.
Metoda PostDrawEvent este metoda care se va aplica după metoda PreDrawEvent,
rolul acestei metode este de a prelua toate obiectele care trebuie să fie desenate și pe baza
dacă trebuie desenat imaginea obiectelor din joc, dacă trebuie desnenat numai text sau trebuie
desenate dreptungiuri, metoda le va desena cu prorietățiile adecvate. Pe lângă aceste roluri
metoda mai are două metode mai importante unul este de a desena inventarul personajului și
de a desena bara de viață al personajului.
Inventarul personajului este un mehanism de joc foarte important pentru că în această
inventar se vor memora armele sau articolele de prim ajutor pe care personajul din joc a
ridicat de pe nivel. Când personajul va ridica un obiect atunci în clasa personajului din joc
Player.java vor face verificări dacă obiectul ridicat este o armă sau un articol de prim ajutor și
va fi creat un nou obiect de acel tip. Clasa Player.java mai are metode care lucrează cu
inventarul cum ar fi metoda addItem care va adauga obiectul însăși în inventar sau metoda
switchToItem care în momentul în care în inventar personajul va schimba arma sau articolul
de prim ajutor atunci va fi făcut semnale că trebuie schimbat imaginiile de joc și trebuie
schimbat indexul care arată ce este selectat în momentul current.
Pentru a lucra cu inventarul a fost creat o clasă abstarctă numită InventoryItem.java
care a fost extins de clasele WeaponItem.java și de HealthItem.java aceste clase au mai fost
discutate mia sus.
Personajul are patru locuri în inventar , pentru a schimba dintre armele sau articolele
de prim ajutor trebuie apăsat tastele 1,2,3 sau 4 pe tastatură, dacă este apăsat unul dintre
aceste tastaturi atunci se va aplica metoda switchToItem și idexul curent va fi schimbat pe
codul tastaturii apăsate.
Pentru desenare inventarului cu ajutorul metodei RectangleToDraw vor fi desenate
patru dreptungiuri de culoare alb cu o opacitate aleasă, dacă o armă sau un articol de prim
ajutor este selectat pe poziția inventarului atunci pe drptungiul ales opacitatea va fi schimbat
pentru a indica că acel poziție este selectat în momentul dat.
20

Când se va ridica o armă sau articole de prim ajutor atunci când este pus în inventar
atunci se va desena în dreptungi cu ajutorul metodei SpriteToDraw va desena o imagine care o
va reprezenta obiectul ridicat depinzând dacă este o armă sau un articol de prim ajutor. Cu
ajutorul metodei TextToDraw se va desena proprietățiile care armele sau articolele de prim
ajutor o au cum ar fi numele armei sau a articolului de prim ajutor, durabilitatea în cazul
armelor sau în cazul articolelor de prim ajutor cât va fi adaugat la viața curentă al
personajului.
Bara de viață va fi desenat de o metodă numită drawHealth. Această metodă va desena
bara de viață prin metoda RectangleToDraw prin care se vor desena două dreptungiuri unul
care va avea o opacitate mare și un dreptungi care va fi desenat pe primul dreptungi, culoarea
acestui dreptungi va începe de la culoarea verde când viața personajului este maxim deci 100
și când personajul pierde din viață atunci mărimea dreptungiului va scade și culoarea se va
scimba din verde spre roșu conform cât este viața curentă al personajului. Cu ajutorul lui
TextToDraw va afișa viața curentă al personajului.
Clasa GameWindows.java are numai funcționarea de a deseneze componenetele ale
programului el nu știe cui să deseneze și când să deseneze, de aceia metodele PreDrawEvent
și PostDrawEvent vor fi suprascrise în clasa GameRoom.java. În această clasă depinzând de
faza în care este jocul în faza de Game, faza de Main_Menu sau faza de Game_over.
Dacă jocul este în faza de Game atunci clasa va aplica metoda DrawEvent pe care
fiecare obiect din joc o are și pentru fiecare obiect din joc va aplica o metodă care are rolul de
a semanla că trebuie desenate imaginiile corespunzătoare obiectului , iar mai trebuie scris
numărul de zombi au fost învinse și cât timp a trecut de la începerea jocului.
Dacă jocul este la faza de Main_menu atunci se va desena fundalul și se va aplica
metoda DrawMainMenu care va desena meniul principal prin desenarea a două dreptungiuri
prin metoda RectangleToDraw și desenarea unui buton cu titlul de Start Game prin metoda
DrawButtons.
Un buton este creat prin clasa abstractă GameButton care are rolul de a iniția o altă
fază al jocului dacă se va da un click în interiorul lui, dacă este în faza de Main_menu atunci
trebuie inițializat faza de Game, dacă viața jucătorului este redus la 0 atunci faza de
Game_over este inițializat dacă se va click pe butonul Play Again atunci iarăși trebuie
inițializat faza de Game.
21

Metoda DrawButtons este similar în funcțiune ca și DrawMainMenu cu ajutorul
metodei RectangleToDraw va fi desenat un dreptungi și cu ajutorul metodei TextToDraw va fi
afișat în buton textul Star Game sau Play Again , depinzând în care fază de joc suntem.
3.5 Sistemul de importare al imaginilor
Fiecare obiect din joc are o imagine care trebuie desenat, aceste imagini trebuie
importate. Lucrurile care trebuie luat în considerare este că trebuie memorat calea fiecărui
folder sau imagine în parte și trebuie luat în considerare faptul că este o șansă ca animații o să
fie prezente în joc. Pentru asta a fost creat clasa GameSpriteFactory.java iar ideia pe care este
bazată metodele de implementare al imaginilor este metoda de factory pattern.
Factory method pattern este bazată pe ideia că se va folosi un obiect pentru a crea alte
obiecte fără a spune cu exactitate din ce clasă va fi creat obiectul, acesta va fi făcut prin creare
de metode de factory care sunt interfețe imlementate de clasele derivate sau metode create în
clasa de bază și suprascise opțional în clasa derivată. Deși clasa GameSpriteFactory.java nu
funcționează în exactitate ca și un factory sunt luate idei din acesta.
În clasă au fost create două enumuri unul se numește PlayerMotion și celălalt se
numește ZombieMotion. Aceste enumuri au fost create pentru a fi folosite la căutarea
fișierelor țiintă al imaginiilor. Pentru că personajul din joc are cele mai multe imagini ce
trebuie găsite și afișate care sunt bazate pe care dintre armele în joc este în folosire și în care
dintre miscările se află personajul din joc pentru asta fost creat o clasă separată cu o metodă
pentru a căuta imaginiile în fișierele corespunzătoare. Acesată metodă din clasă va verifica
obiectul personajului din joc și verifică în ce mișcare se află în moment și ce armă este folosit
de personaj. Pentru a găsi calea corectă al imaginilor a fost creat o formă generală al calei în
care mișcarea , tipul armei și numărul imaginii au fost înlocuite cu variabilele &mtn, &wpn, și
&num. În metodă vor fi verificate mișcarea și tipul de armă și dacă este deja prezent atunci se
va afișa imaginea care va fi de un tip clasă numită GameSprite.java. Dacă nu există deja
această imagine atunci se va înlocui &wpn cu numele al armei și &mtn cu mișcarea și se va
înlocui &num cu un număr crescător pâna la momentul în care nu mai sunt imaginii de
importate în fișier. Aceste imagini vor fi puse întro listă numită imageURL și bazată pe căile
create cu ajutorul metodei se vor desena imaginiile.
Pentru importarea și desenarea imaginilor asociate zombiilor se va folosi o metodă
asemănătoare ca de la personaj cu diferența că înlocuirea se va face pe baza enumului
22

ZombieMotion, se va înlocui variabila chosenMotion cu numele mișcării al zombiului și ca și
la personaj se va plasa calea creată într-o listă numită iamgeURL și se va afișa toate imaginile
care au călile puse în imageURL.
Pentru imaginile armelor , articoleleor de prim ajutor , imaginile ce vor fi afișate în
inventar , imaginea glonțului și imaginile ce sunt incluse în fundal sunt folosite același metode
dar pentru că sunt mai puține imagini putem să dăm calea imaginilor pentru fiecare armă sau
articol de prim ajutor în parte depinzând de tipurile acestora sau putem da glonțului și
imaginilor din fundal doar calea necesară pentru a găsi imaginea dorită.
Clasa mai are trei variabile importante ZOMBIE_RADIUS, PLAYER_RADIUS și
BULLET_RADIUS care sunt importante la verificarea coliziunii dintre obiectele din joc,
aceste valori sunt calculate pe baza dimensuinii imaginilor. Aceste variabile sunt folosite
pentru o verificarea mai exactă al distanței de atac.
Toate aceste metode din clasă crează imagini care sunt de tip GameSprite care sunt din
clasa GameSprite.java. Această clasă este responsabilă pentru setarea proprietățiilor
imaginilor și mai multe roluri.
Un rol foarte important al clasei este de a calcula viteza la care animațiile trebuie să fie
executate, la fiecrare ciclu al procesorului trebuie calculat pe baza vitezei implicite și mărimea
imagini, și de a decide dacă imaginile sunt imagini care trebuie repetate deci trebuie desenat
animațiile.
Un alt rol important este de a calcula dimensiunea boundingCircleRadius.
BoundingCircleRadius este un cerc invisibil care acoperă iamginea și este calcualată de clasă
pe baza dimseniunea imaginii.
BoundingCircleRadius este folosit pentru a detecta dacă două obiecte din joc sunt în
coliziune. Două obiecte din joc sunt în coliziune dacă cercurile ale obiectelor sunt în acoperire
una cu cealaltă. Dacă folosim aceste cercuri atunci putem să facem o verificare de coliziune
mai precisă.
3.6 Personajul din joc
Personajul din joc este implementat prin clasa Player.java. Clasa are multe rolulri de
implementat pentru că acesta este un catalist pentru multe evenimente din joc.
Clasa extinde clasa GameObject.java și implementează interfețele Damagable și
DamageInflicter.
23

Interfețele Damagable și DamageInflicter au fost create pentru a decide în momnetul
atacului cine este atăcat și cine atacă.
Interfața Damagable are metode pentru a prelua viața obiectului și cât va pierde din
viața lui totală.
Interfața DamageInflicter are metode pentru a prelua informația de cât este distanța
minimă la care se pot ataca cu arma și o metodă care va decide cu ce obiecte este la acea
distanță minimă.
Pentru că conținutul inventarului și care este arma sau articolul de prim ajutor curent
folosit depinde de interacșiunea cu această clasă.
A fost creat o clasă internă numită PlayerInventory care este folosit la lucrul cu
inventarul personajului. Această clasă are mai multe metode pentru a lucra cu inventarul, o
metodă importantă este metoda getCurrentItem care returnează indexul current al inventarului
care va fi de tip InventoryItem. O altă metodă addItem este metoda care verifică tot inventarul
și dacă găsește o poziție care este null atunci poziția acela va fi setat cu arma sau articolul de
prim ajutor.
O altă metodă importantă este removeItemsWithZeroDurability care verifică
totalitatea inventarului și verifică dacă durabilitatea armelor a ajuns la zero atunci poziția
unde se află acest armă trebuie dat o valoare de null.
O altă metodă importantă numită switchToItem are rolul de a schimba arma sau
articolul de prim ajutor current și dacă este o armă la care este schimbat atunci trebuie
schimbat la imaginea corespunzătoare. Schimbarea la arma curentă se face prin verficarea
tipului armei.
Ultimul metodă importantă al clasei este de a aplica metoda de desenare al
inventarului care este definit în interfața GameView și suprasris în clasa GameWindow.java.
În afara clasei interior create sunt metode și anumite evenimente care trebuie aplicate
la fiecare ciclu, cum ar fi dacă un set de imagini care au fost deja desenate trebuie resetat
imaginiile pentru arma curentă pentru a nu repeta animațiile. Metoda
removeWithZeroDurability este o metodă care trebuie aplicat în fiecare ciclu. Jocul va fi
terminat dacă viața personjului din joc va fi redus la zero deci verificarea trebuie să fie făcută
în fiecare ciclu pentru ca jocul poate fi oprit în orice moment. Dacă sa constatat că viața este
zero atunci se va aplica metoda initGameOver. Metoda initGameOver este o metodă
declarată în clasa GameRoom.java care inițializează meniul de Game Over, după ce se setează
24

faza de joc la GAME_OVER se va preia cât timp a supraviețuit și se va face o conexiune cu
baza de date în care se află valorile care descrie tabela de highscore. În această metodă se va
face compararea a valorilor obținute de jucătorul curent cu toate celălalte valori obținute de
alți jucători pentru a decide dacă rezultatele obținute să fie incluse în tablă, dacă rezultatul
este da atunci dacă sunt rezultate care nu mai sunt bune pentru tabelă atunci trebuie șterse din
baza de date.
Clasa mai lucrează cu coliziunea obiectelor, depinzând de tipul al obiectului cu care se
face coliziunea dacă este armă sau articol de prim ajutorm dacă se face coliziune atunci
trebuie creat un nou weaponObject sau un healthObject și trebuie verificate proprietățiile
acestuia.
O altă metoda inAttackRangeEvent este o metodă suprascrisă al interfeței
DamageInflicter acesată metodă în această clasă va adauga toate obiectele care sunt
Damagable și sunt în distanță minimă al armei curent pentru a ataca și de a registra ca un atac.
Metoda getAttackRange este o metodă care este suprascrisă și returnează distanța
minimă la care se poate ataca cu arma selectată, dar asta se va aplica numia dacă arma curentă
este o armă de tip MeleeWeaponItem.
Pentru că personajul din joc trebuie să urmărească poziția mouseului acesta trebuie să
fie calculată. Acesta va fi calculată cu ajutorul metodei calcAngleBasedOnMouse acesta va
face calcule pe baza poziției mouseului și va returna poziția mouseului în radiani.
3.7 Zombi din joc
Zombi sunt inamici din joc și are două mari roluri, de a urmări personajul din joc și de
a ataca personajul dacă sunt la o distanță mică.
Clasa Zombie.java extinde clasa GameObject.java și implmentează interfețele
Damagable și DamageInflicter.
A fost creat o metodă numită calcAngleBasedOnPlayerPos care se bazează pe
calcAngleBasedOnMouse care va fi folosit pentru identificarea poziției personajului deci va fi
calculat ungiul personajului prin coordonatele lui care ulterior vor fi convertite în radiani.
Sa va suprascrie metoda inAttackRangeEvent care a fost creat în interfața
DamageInflicter și va fi verificat dacă personajul din joc este la distanța ncesară pentru a fi
atacat și dacă da atunci personajul va pierde din viața totală egală cu o valoare predefinită.
25

O altă metodă suprascrisă care aparține interfeței DamageInflicter este
getAttackRange care returnează distanța pentru a fi folosit în clasă.
Metoda suprascisă damage este o metodă suprascrisă care aparține interfeței
Damagable care va fi folosit când zombi va fi atacat, dacă se întâmplă asta atunci trebuie
sustras din viața lui zombi cu un amănunt prestabilit.
În joc dacă a fost omorât un zombi atunci în locul lui mai trebuie creat un zombi.
Pentru a realiza acest lucru trebuie creat o metodă care a fost numit spawnZombie, această
metodă are rolul de a crea zombi.
Această metodă este asociat cu dificultatea jocului, pentru că cu cât mai mult durează
jocul curent cu atât mai multe zombi vor fi create , aceste zombi create trebuie create întrun
poziție întâmplător în locul de joacă. Dar există un număr maxim de zombi care pot fi prezneți
în joc în același timp acest număr fiind 50 , când este creat un zombi nou numărul zombiilor
trebuie crescut, iar când este omorât un zombi atunci numărul zombiilor prezente în joc
trebuie redus.
Cu cât durează mai mult jocul noile zombi create vor fi mai puternice în termeni de
viteza la care vor urmări personajul și cât vor lua din viața totală al personajului după un atac
reușit.
Multe dintre aceste metode trebuie verificate la fiecare ciclu și aplicate de aceia la
fiecare ciclu trebuie verificat coordonatele curente al personajului și trebuie aplicat
coordonatele la metoda calcAngleBasedOnPlayerPos și pe baza acestui metodă trebuie decis
dacă zombi poate să miște spre poziția jucătorului prin verificarea metodei nextPosCollision
acesta este o metodă al clasei GameObject care verifică dacă următoarele coordonate vor fi în
coliziune. Metoda isInRoom care este declarat în GameRoom.java va verifica dacă noile
poziții la care trebuie să se miște sunt încă în terenul de joc, dacă la aceste rezultate sunt da
atunci se va aplica metoda move care este declarat în clasa GameObject.java
O altă rol care trebuie verificat și aplicat în fiecare ciclu este de a verifica mișcarea
curentă al zombiilor și pe baza distanței dintre zombi și personaj dacă acesta este la o distanță
de a ataca personajul, asta este imporant pentru că pe baza acestori mișcări și distanțe trebuie
decis care imagini să fie desenate.
Mai trebuie verificat dacă un zombi a fost ucis, dacă este da atunci trebuie schimbat
mișcarea la DEATH și trebuie schimbat imaginea la imaginea corespunzător.
26

3.8 Implementarea bazei de date
Implementarea bazei de date este un proces mai lung, pentru că trebuie implementată
partea de server și trebuie implementat și partea al programului pentru a putea conecta la
această bază de date.
Pentru a lucra cu o bază de date locală trebuie creat unul pentru asta a fost solosit
progmul MySQL Server .
Când vream să creăm o baza de dată local acesta trebuie configurat prima dată, primul
lucru este de a decide ce fel de tip de server vrem să creăm și tipul de conexiune pe care vrem
să facem,în cazul nostru serverul o să fie de tip development adică nu o să fie o mașină pură
care va lucra numai cu serverul astfel nici nu o să fie consumată o cantitate de
memorie.Conexiunea o să fie de tip TC/IP la numărul de prt 3306.
Următorul pas este de a crea o parolă pentru contul de root, în cazul nostru parola
aleasă este root1234.
Pasul final al configurări serverul MySQL este de a decide dacă vream ca serverul să
fie creat ca și un service Microsoft. Dacă alegem să creăm în acest mod atunci serverul poate
să ruleze în fundal întotdeauna de la momentul în care sistemul este pornit, dar dacă vrem să
terminăm executarea serverului atunci putem să căutăm serviciile microsoft prezente pe
sistem și se poate termina executarea sa. La implementarea nosatră a fost ales să se
implmenteze ca și un serviciu microsoft cu numele de MySQL57. Iar trebuie ales ce fel de
cont și sistemul de securitate să fi prezent pe cont în cazul nostru sau ales contul standard.
MySQL Workbench este un intrument grafic pe care putem folosi pentru lucrul cu
bazele de date, în MySQL Workbench putem crea conexiuni prin care putem să conectăm la
bazele de date.
27

Fig 3.1. Conexiunile realizate în MySQL Workbench
A fost realizat o conexiune numită GameConnection care aparține contului cu nume
root la adresa de 127.0.0.1 cu portul TCP/IP de 3306. Când vream să ne contectăm la baza de
date prin această conexiune atunci trebuie introdus parola root1234 pentru că conexiunea este
asociată cu baza de date la care parola este același.
După logare putem să începem lucrul cu bazele de date. A fost creat o schemă numită
highscore_schema, iar în această schemă a fost creată o tabelă numită highscore.
În tabelă au fost create patru coloane care sunt: idhighscore care va fi cheia priamară
al tabelei care este de tip int(11) și are proprietatea că se auto incrementează, player_name de
tip varchar(45) în acest coloană va fi memorat numele jucătorului, time de tip longtext
coloana în care va fi memorat timpul care jucătorul a supraviețuit și zombies_killed de tip
int(11) coloană în care va fi memorat numărul de zombii omorâte de jucător.

Fig 3.2. Tabela highscore
La început nimeni nu a jucat cu jocul încă deci tabela ar fi fost gol deci trebuie
introdus valori în tabelă. Cu ajutorul SQL-ului prin afirmația INSERT INTO au fost introduse
20 de elemente în tabelă.
Pe partea al programului pentru ca programul să recunoască și să știe să facă
conexiunea dintre baza de date și conexiunile dintre obiectele din program și elementele din
baza de date, trebuie creat un folder nou numit META-INF în folderul de resurse folosite de
program și trebuie creat un nou xml numit persistance.xml.
28

În persistance.xml trebuie să dăm care clasă din program să fie asociat cu tabela din
baza de date folosită.
Mai trebuie să dăm numărul portului prin care se va face conexiunea care în cazul
nostru este 3306 și numele schemei în care se va căuta tabela care în cazul nostru este
highscore_schema, și mai trebuie să dăm numele de utilizator și parola.
Persistanța este dată de un framework numit hibernate, care o să facă asociația dintre
datele din tabel și cele din program.
Prin persistență vorbim de acele date care o să se trăiască mai mult decăt metodele pe
care le-au creat, deci hibernate o să folosească limbajul de Java Persistance API(JPA).
Fig 3.3. Persistance.xml
După ce a fost creat persistance.xml a fost creat un nou pachet numit persistance în
care vor fi create clasele care vor lucra cu baza de date.
Clasa Highscore.java este clasa care va reprezenta tabela highscore din baza de date,
deci această clasă va fi folosit de un framework pentru a afla purtarea metodelor din clasă.
Pentru implementare o să folosim anotații, adică trebuie să dăm numele tabelei cu care
vrem să lucrăm în cazul nostru highscore și trebuie să dăm numele coloanelor cu care o să
lucrăm, deci prin această clasă o să creăm entiăți.
Clasa DBConnection.java este clasa care o să facă conexiunea la baza noastră de date.
29

Pentru că datele noastre sunt folosite prin entități conexiunea trebuie să fie făcută prin
aceste entități, iar lucrul cu entitățiile sunt făcute prin entityManageri. Un entityManager este
o instanță al persitenței care o să creeze și distrugă instanțe de entități și să identifice prin
cheile lor și de a interoga pe aceștea.
Metoda creată getEntityManager are rolul de a crea aceste entityManageri prin
folosirea unui entityManagerFactory, un entityManagerFactory este o instană care va crea
aceste entityManageruri.
Metoda creată close are rolul de a viziona toate entityManagerurile create și a verifica
dacă acele entityManageruri sunt deschise și dacă răspunsul este da atunci aceste trebuie
închise.
A mai fost creat o clasă numită DBConnectionException care va extinde subclasa
Exception. Această clasă a fost creată pentru a gestiona excepțiile care ar putea apărea pe
parcursul execuției programului. Această clasă are metode care vor putea afișa mesagel pe
baza ce excepție sa întâmplat.
Probabil cel mai important clasă creată este clasa HighscoreDAO.java, în această clasă
vor fi create metode care vor lucra cu datele din bazele din date.
Metoda insertNewHighscore care va extinde clasa DBConnectionException și are
rolul de insera valori noi în baza de date. Această metodă are un entityManager care va fi
preluat de la clasa DBConnection.java și pe baza acestui entityManager va fi creat un nou
entityTransaction. Un entityTransaction este o instanță al persistenței care este folosit pentru a
controla tranzacțiile al enityManagerilor cu date locale.
În metoda noastră după crearea tranzacției acest atrebuie început și informațiile care
primește de la tabela highscore trebuie persistate iar la final trebuie finalizate aceste
informații, iar la finalul tuturor tranzacțiilor trebuie închis entityManagerul.
Metoda getHighscores care va extinde clasa DBConnectionException are rolul de a
afișa informațiile aflate în baza de date. În metodă o să folosim un entityManager care va fi
preluat din DBConnection, după crearea acestui entityManager cu ajutorul acestui
entityManager vom folosi un query folosind createQuery cu afirmația SELECT h FROM
Highscore h care va uita peste toate elementele din tabelă, iar tabela va fi asociată cu clasa
Highscore.java și va trimite aceste aceste rezultate pentru afișat, iar la finalul execuției
entityManager trebuie să fie închis.
30

Metoda deleteHighscore care va extinde clasa DBConnectionException are rolul de a
șterge elementele din tabelă. În metodă vom folosi un entityManager care va fi preluat din
DBConnection și pe baza asta va fi creat un entityTransaction cu care pe baza id-urilor din
clasa Highscore vor fi căutate elemtele și vor fi șterse din bazele de date și aceste schimbări
trebuie să fie finalizate.La finalul execuției aceste entityManageri vor fi închise.
Ultimul metodă care a fost creat este numit closeEntityManager care va extinde clasa
DBConnectionException va avea rolul de a închide entityManagerurile după finalizarea
execuțiilor necesare. Această metodă creată este metoda care este folosită de celălalte metode
pentru a închide entityManagerurile.
Toate aceste clase sunt aplicate în clasa GameRoom.java. Pentru că tabela din baza de
date trebuie afișat numai la ecranul de Game Over de aceia clasele vor fi aplicate în metoda
initGameOver.
Metoda getHighscore va fi aplicat fiecare dată când se va aplica initGameOver, iar
metoda deleteHighscore trebuie să fie aplicată numai dacă rezultatele obținute din sesiunea de
joc sunt mai mare decât unul dintre cele 20 de rezultate obținute anterioare de alți jucători
deci acele rezultate care nu mai sunt bune pentru tabelă trebuie șterse.
Metoda insertNewHighscore va fi aplicat în metoda playAgainPressed adică noile
rezultate trebuie inserate după ce a fost apăsat butonul Play Again sau dacă a fost apăsat tasta
enter după am introdus numele jucătorului.
3.9 Implemetarea Mavenului
Pentru a putea folosi Apache Maven pentru acesta nu este de ajuns de a instala
programul pentru a folosi acest program trebuie creat o variabilă PATH de tip mediu. În cazul
nostru a fost ales calea C:\Users\Admin\apache-maven-3.5.0-bin\apache-maven-3.5.0, și după
asta a fost creat POM.xml.
Un mare avantaj mare al lui Apache Maven este este ușor menegmentul depedențelor.
În Apache Maven nu este necesar de a căuta și de a insera fiecare librărie în parte pentru
fiecare dependență.
Deci și în programul nostru trebuie să inserăm anumite dependențe cum ar fi
hibernate-core, hibernate-entitymanager și mysql-connector-java.
Hibernate-core este folosit în program pentru a furniza funcționalitățiile de bază al
hibernatului.
31

Hibernate-entitymanager este folosit în program pentru a furniză funcționalitățiile
asociate cu persistența și cu asocierea al datelor din program cu cele din baza de date.
Mysql-connector-java este folosit în program pentru a furniza driverul care va
implementa Java Database Connectivity(JDBC) API.
În POM.xml trebuie inserat numai aceste definiții și Apache Maven va descărca toate
resursele necesare.
CONCLUZII
În legătură cu aplicația creată cred că am realizat tot ce am vrut să realizez. Cu scopul
acestei aplicație am vrut să realizez un joc simplu care să fie distractiv dar în același timp să
fie distractiv și pentru o persoană care de obicei nu joacă jocuri video.
Pe parcursul elaborări aplicației am realizat cât de comlex poate un joc video să fie
chair și în cazul aplicației mele care este mai simplu, am aflat că întrun joc video sunt multe
mecanisme care sunt întrun strânsă relație una cu celălalt, și am mai învățat multe noutăți
despre subiecte despre aveam cunoștințe anterioare despre JavaFX sau MySQL.
Pe viitor această aplicație ar putea fi îmbunătățită prin introducerea unor noi varietăți
de zombi care răspund în mod diferit la acțiunile jucătorului, implementarea unor noi arme, și
implemtarea unor noi articole de prim ajutor.
32

BIBLIOGRAFIE
[1] https://docs.oracle.com/javase/8/javafx/get-started-tutorial/jfx-overview.htm#JFXST784
consultat la 06.10.2017
[2] https://docs.oracle.com/javase/8/javafx/api/javafx/scene/doc-
files/cssref.html#introscenegraph consultat la 10.10.2017
[3] https://docs.oracle.com/javase/8/javafx/api/javafx/application/Application.html consultat
la 20.10.2017
[4] https://docs.oracle.com/javase/8/javafx/api/javafx/scene/Scene.html consultat la
03.11.2017
[5] https://docs.oracle.com/javase/8/javafx/api/javafx/stage/Stage.html consultat la 10.11.2017
[6] https://en.wikibooks.org/wiki/Computer_Science_Design_Patterns/Model
%E2%80%93view%E2%80%93controller consultat la 20.11.2017
[7] http://books.sonatype.com/mvnref-book/pdf/mvnref-pdf.pdf consultat la 25.11.2017
[8] https://dev.mysql.com/doc/refman/5.7/en/what-is-mysql.html consultat la 05.12.2017
[9] https://dev.mysql.com/doc/workbench/en/wb-intro.html consultat la 08.12.2017
33