UNIVERSITATEA DE STAT DIN MOLDOVA

Facultatea de Matematică și Informatică

Departamentul Informatică

Pavalachi Alina,
studenta grupei IA2001

Raportul de practică

Conducătorul științific:

Chișinău, 2022
 CUPRINS
INTRODUCERE.............................................................................................................................3
1. CERCETĂRI TEORETICE DESPRE PYTHON ȘI GRAFICA PIXEL ART...........................4
1.1. Prezentarea generală rezultatelor din domeniul dat..............................................................4
1.1.1.........................................................................................................................................4
1.2. Analiza comparativă.............................................................................................................4
1.2.1.........................................................................................................................................4
1.2.2.........................................................................................................................................4
1.3. Selectarea și descrierea mijloacelor instrumentale...............................................................4
1.3.1.........................................................................................................................................4
1.3.2.........................................................................................................................................5
1.3.3.........................................................................................................................................6
2. ELABORAREA PROIECTULUI...............................................................................................7
2.1 Elaborarea personajului.........................................................................................................7
2.1.1.........................................................................................................................................7
2.1.2.........................................................................................................................................7
2.1.3.........................................................................................................................................9
2.2 Elaborarea inamicilor..........................................................................................................10
2.2.1.......................................................................................................................................10
2.2.2.......................................................................................................................................11
2.2.3.......................................................................................................................................12
2.3 Elaborarea hărții..................................................................................................................12
2.3.1.......................................................................................................................................12
2.3.2.......................................................................................................................................13
2.3.3.......................................................................................................................................13
3. REALIZAREA PROIECTULUI...............................................................................................15
3.1 Structura logică a jocului.....................................................................................................15
3.1.1.......................................................................................................................................15
3.1.2.......................................................................................................................................18
3.1.3.......................................................................................................................................20
3.2 Crearea unui nivel................................................................................................................21
3.2.1.......................................................................................................................................21
3.2.2.......................................................................................................................................22
3.2.3.......................................................................................................................................23
CONCLUZII..................................................................................................................................25
BIBLIOGRAFIE...........................................................................................................................26
ANEXA.........................................................................................................................................27

2
 INTRODUCERE
Python este un limbaj de programare de nivel înalt, cu tastare dinamică, axat pe îmbunătățirea
productivității dezvoltatorilor[1]. Limbajul este complet orientat pe obiecte. Sintaxa limbajului
de bază este minimalistă, din cauza căreia în practică rareori se face referire la documentație.
Limbajul este folosit pentru scrierea de scenarii. Dezavantajele limbajului sunt adesa viteza mai
mică și consumul mai mare de memorie, comparativ cu codul similat scris în C++ sau C.
Biblioteca standard include un set mare de funcții portabile utile pentru scrierea aplicațiilor[2].
Instrumentele suplimentare, precum ar fi modelarea matematică, scrierea de aplicații web sau
dezvoltarea jocurilor, pot fi implementate printr-o gamă largă de biblioteci, precum și integrarea
acestora.
Python a devenit unul dintre cele mai populare limbaje, fiind folosit în analiza datelor, DevOps și
dezvoltarea web, inclusiv dezvoltarea jocurilor[3]. Datorită lizibilității, sintaxei simple și nu
necesită compilare, limbajul este foarte potrivit pentru predarea programării, permițându-vă să vă
concentrați asupra algoritmilor, conceptelor și paradigmelor. Python este pe larg folosit de multe
companii mari, precum ar fi Google sau Facebook.
Pixel art este o formă de artă digitală, desenată cu software, prin care imaginile sunt construite cu
plasarea exclusivă și intenționată a pixelilor[4]. Este folosită pe scară largă în grafica de joasă
rezoluție de la PC-urile pe 8/16 biți și consolele de jocuri video.
Definiția pixel art-ului a fost un subiect constant de discuție între artiști. În general, artistul
acordă o importanță deosebită fiecărui pixel al unei imaginii. Pentru a obține această estetică
minimalistă, majoritatea lucrărilor de pixel art sunt restrictive în ceea ce privește dimensiunea
fișierului și numărul de culori utilizate în paleta de culori.
Desenarea sau modificarea personajelor sau obiectelor pixel art pentru jocuri video este numită
spriting. Termenul provine de la sprite, un concept folosit în grafica computerizată pentru a
descrie un bitmap bidimensional care este folosit în tandem cu alte bitmap-uri pentru a construi o
scenă mai mare[5].
Pixel art-ul rămâne în continuare popular, fiind des întâlnit în proiectele de la Nintendo.
Motivele pentru utilizarea pixel art-ului în jocurile video moderne includ faptul că provoacă un
sentiment de nostalgie pentru jocurile video clasice, este iconic, se folosesc fișiere de
dimensiumi mai mici, nu necesită un PC puternic pentru a fi create (spre deosebire de arta 3D),
economisește timp la compilarea jocurilor, funcționează bine pe ecrane mici precum
smartphone-urile și rămâne o alegere estetică populară[6].

3
 1. CERCETĂRI TEORETICE DESPRE PYTHON ȘI GRAFICA
PIXEL ART

1.1. Prezentarea generală rezultatelor din domeniul dat

1.1.1. Scopul proiectul a fost de a dezvolta o joacă 2D pe baza graficii pixel, trecând prin
toate etapele de creare a unui joc. Totul începe cu o idee, apoi schematica și caricaturi. Alegerea
limbajului de programare la fel este un punct esențial la început. Apoi se trece la desenarea
graficii și animațiilor, discutarea mecanicii de joc și efectelor necesare pentru redarea atmosferei
sau a anumitor stări emoționale. Jocurile nu trebuie să se bazeze doar pe mecanică, dar și pe
emoțiile care doresc dezvoltatorii să impuie în jucători. Orice joc are o atmosferă, iar detalii bine
aranjate și gândite vor ilustra cele mai neuitate aventuri într-o lume nouă.

1.2. Analiza comparativă

1.2.1. A fost selectat limbajul Python pentru crearea jocului din motivul că este relativ
mai ușor de folosit decât același Unity sau Unreal. Cu jocurile de tipul dat, Python este un limbaj
potrivit și se descurcă foarte bine cu toate cerințele. Python ocupă puțin spațiu, iar jocurile vor
merge bine pe orice PC/telefon. Biblioteca Pygame are toate instrumentele necesare pentru a
crea un joc 2D.

1.2.2. Grafica Pixel Art rămâne una dintre cele mai populare. Datorită efectului de retro,
stilul dat redă o atmosferă diferită. Iar în jocurile 2D este chiar cea mai potrivită și ușor de
desenat. Se zice că în Pixel art nu există detalii, ceea ce este incorect, detalii sunt minimizate,
însă oricum persistă.

1.3. Selectarea și descrierea mijloacelor instrumentale

1.3.1. Pentru a elaborarea personajelor a fost folosit un soft special. În cazul dat va fi
sistemul Aseprite, conceput pentru desenarea graficii în stilul pixel art[7]. Interfața este intuitiv
clară și user-friendly. Scopul principal este de a crea sprite-uri. Un sprite este un bitmap
bidimensional care este integrat într-o scenă mai mare.
Unele dintre caracteristicile soft-ului Aseprite:
- Straturi și cadre, cu grupare de straturi și etichetare animației

4
 - Transformări și instrumente specifice pixel-art
- Vizualizarea în timp real a animației
- Tilemap și tileset
- Gestionarea paletei de culori
- Profiluri și moduri de culoare
- Non-square pixels

Fig. 1.1

1.3.2. Elaborarea hărților pentru nivele se va efectua în programul Tiled. Este foarte
flexibil, poate fi folosit pentru a crea hărți de orice dimensiune, fără restricții privind numărul de
straturi, care pot fi utilizate. Tuturor obiectelor li se pot atribui proprietăți arbitrare. Formatul
hărții Tiled (TMX) este ușor de înțeles și permite utilizarea mai multor seturi de casete pentru
orice hartă[8]. Tileset-urile pot fi modificate în orice moment.
Tiled poate gestiona plăci de perspectivă dreptunghiulară, hexagonală și izometrică și permite
adăugarea de zone de coliziune care nu vor fi afișate la ecran. Diverse motoare principale de
software suportă formatul TMX. De asemenea, este posibil importarea în Unity, folosind
pluginul SuperTiled2Unity.XML

5
Fig. 1.2

1.3.3. PyCharm este mediu de dezvoltare integrat pentru limbajul Python[9]. PyCharm
este dezvoltat de JetBrains pe baza IntelliJ IDEA. Utilizatorii pot elabora propriile pluginuri,
extinzând capacitățile PyCharm[10].
Caracteristici:
- Asistență și analiză, cu completarea codului, evidențierea sintaxei și a erorilor
- Navigare prin cod: vizualizări specializate ale proiectelor, vizualizări ale structurii
fișierelor și sărituri rapide între fișiere/clase/metode
- Refactorizarea Python: include redenumirea, metode de extragere, introducerea
variabilei, constantei
- Integrated Python debugger
- Testare unitară integrată, cu acoperire line-by-line
- Integrarea controlului versiunilor: interfață de utilizator unificată pentru Git
- Suport pentru instrumente științifice precum Matplotlib, NumPy și SciPy

Fig. 1.3

6
 2. ELABORAREA PROIECTULUI

2.1. Elaborarea personajului

2.1.1. Pentru a elabora un personaj, prima etapă ar fi să fie înțeles scopul acestui
personaj. Pentru că de obiective depind caracteristicile și aspectul personajului. A fost gândit
următoarele lucruri:

 Pentru ce este nevoie de personajul dat?

 Ce sarcini ar trebui să rezolve?
 De câte ori, unde și cum va fi folosit?
 Dacă personajul va fi reprezentat într-o singură ipostază sau se vor schimba
 Dacă ilustrația va fi animată
Răspunsurile la aceste întrebări vor ajuta să orientăm și să înțelegem dacă trebuie să elaborăm
personajul în detaliu sau dacă pozițiile de bază și o cantitate minimă de detalii vor fi suficiente.
Etapa a doua ar fi evaluarea importanței unui personaj. Acest element este relevant dacă sunt
implicate mai multe personaje. Trebuie să fie conceput ce rol să fie atribuit fiecărui dintre ei.
Cine este principalul și cine este personajul secundar. Sau poate că toate personajele sunt la fel
de importante și nimeni nu ar trebui scos în evidență. Aceste detalii vor afecta și aspectul.
Iată câteva lucruri care trebuie să fie atribuite fiecărui personaj:
 Principal sau secundar
 Pozitiv sau negativ
 Parte dintr-un grup sau singur
În cazul dat, este nevoie de un personaj principal, pozitiv care ar nimici monștrii în calea sa, nu
va face parte dintr-un grup momentan.

2.1.2. Următoarea etapă este descrierea aspectului fizic al personajului. În această etapă,
ilustratorii încep să schițeze, pentru că informațiile generale sunt deja suficiente: baza este, iar
apoi este timpul să fie perfecționat caracteristicile fizice ale personajului. Poate că va fi mare, cu
nas proeminent și mustață. Sau, invers, va fi slab și înalt. Corpul lui este proporțional sau dacă o
parte va fi puternic accentuată. Poate va avea picioare lungi și urechi de formă ciudată. Pe lângă
caracteristicile fizice, trebuie să fie gândit modul în care va fi îmbrăcat personajul, ce coafură
are.
Ce este important în aspectul personajului:
 Trăsăturile feței și forma corpului

7
  Proporții
 Haine
 Coafură
Etapă care urmează este legată de caracterul personajului. După ce au apărut primele schițe,
caracterul personajului începe a ieși la iveală. Caracterul se reflectă mereu în aparență. De
exemplu, dacă personajul este foarte inteligent și erudit, îi se desenează ochelari și o carte în
mâini. Sau trebuie să fie subliniată frivolitatea, atunci îi se adaugă un zâmbet larg ridicol. Dacă
reprezentarea personajului este bună, atunci detaliile care îi transmit caracterul s-ar putea să nu
fie atât de banale. Imaginea alăturată reprezintă prima schiță a
personajului jocului. Din ilustrația dată se ajunge la
concluzia că personajul va fi un individ în costum
de raton, însă cu o inimă mare care este desenată pe
corpul acestuia.

Fig. 2.1

8
 2.1.3. Următoarea etapă este ilustrarea emoțiilor. Gândirea la expresiile faciale ale
personajului este o etapă importantă a muncii. Trebuie să fie subliniată reacția în diferite situații:
fericit, supărat, râzând. Cum se schimbă fața și corpul lui când plânge sau gândește.
Pentru a alege cele mai benefice emoții pentru personaj, ilustratorul realizează o difuzare, unde
înfățișează personajul în diferite stări. Numărul de stări depinde de situație. Când un personaj
este necesar doar pentru plasarea pe pagina principală a site-ului, ne putem limita la emoțiile de
bază. Dacă trebuie să fie povestită o istorie, spectrul de stări emoționale va fi mult mai larg.
Următorul pas ar fi mișcarea personajului. După ce s-au subliniat emoțiile și expresiile faciale,
trebuie să fie ilustrat modul în care se va mișca personajul.
Un personaj nu este o imagine statică, ar trebui să fie ca una vie. Prin urmare, dinamica imaginii
este importantă. Pentru a înțelege comportamentul personajului în diferite situații, ilustratorul
realizează o întindere de 5-6 ipostaze. De exemplu, modul în care personajul merge, cade, stă.
Pentru personajul nostru vor fi create câteva ipostaze de bază (cadrele din animația de bază):
- idle, inactive, reprezentate în Fig 2.2

Fig. 2.2 Ipostaza ”idle”

- jump, săritură reprezentate în Fig 2.3

Fig. 2.3 Ipostaza ”jump”

- run, alergare reprezentate în Fig 2.4

9
Fig. 2.4 Ipostaza ”run”

2.2. Elaborarea inamicilor

2.2.1. Inamicii sunt una dintre figurile cheie, fără de care un joc își poate pierde sensul,
iar când acești inamici sunt și monștri, ei creează atmosfera. Monștrii sunt o imagine colectivă a
inamicului din joc, nu poate fi doar un demon urât sau păianjen uriași, chiar și un vecin rău este
un monstru, în ciuda aspectului de persoană.
Uneori observăm cazuri de incompatibilitatea locației cu inamicul, spre exemplu, o broscă în
deșert sau golem de gheață în peșterile de lavă, toate sunt unite de un habitat nenatural. Astfel de
inconsecvențe sunt relevante doar într-un singur caz – sunt complot elaborate și corespund
istoriei. Adăugarea unui personaj trebuie să fie întotdeauna justificată, fie prin intrigă, fie prin
faptul că acest habitat este într-adevăr potrivit pentru el și nu există nicio contradicție. Astfel
primim formula: monstru = creatură + habitat + logică.
Și pentru asta există analogi buni. Natura deja ne-a spus totul. De exemplu, creaturile subterane
au o vedere slabă. Rechinii au 3 rânduri de dinți, o falcă retractabilă și o formă a corpului
raționalizată pentru viteză. Există soluții pentru orice, chiar și pentru ființe de pe altă planetă.
Creierul uman nu poate percepe ceva fundamental diferit, pentru că nu va înțelege ce e.
Rezumând cele spuse mai sus, voi evidenția punctele cheie pentru crearea unui adversar logic:

 Determinăm locul de reședință

 Căutăm analogi
 Istoria
 Stabilim locul în lanțul alimentar
 Determinăm caracteristicile evolutive și ale scenariului
 Realizarea unui concept

10
 2.2.2. Următorul pas ar fi mecanică de acțiuni ale adversarului. Pentru a explica mai bine
voi lua un exemplu. Vom lua 5 golemi. Golem – o creatură magică, de regulă în jocuri arată ca o
statuie de lut animată, de dimensiuni uriașe.
Ziceam că luăm 5 golemi, presupunem că vor fi:
1. din gheață
2. de foc
3. argilă
4. metal
5. oase (de ce și nu)
Să luăm pe fiecare la rând și să-i descriem câte un concept.
1. Golem din gheață:
Se împarte în mi de fragmente mici și zboară spre jucător, arată frumos – un golem sinucigaș.
Bineînțeles că dăunează mult.
2. Golem de foc
Desigur, dă foc la tot ce este în jur și atacă cu foc, putem doar să-i dăm foc și acest efect este
suficient. Aici întrebarea este în atacurile lui, am 2 opțiuni. Prima este o suflare de foc, a doua
este o minge de foc obișnuită. Nimeni nu a anulat loviturile grele, dar fiecare golem se poate
lăuda cu asta.
3. Golem din argilă
Un golem obișnuit, care se grăbește înainte, prost, lent și stângaci, este imun la orice magie.
4. Golem de metal
Se desface și folosește magia pentru a crea un vărtej metalic. Deoarece aceasta este o creație a
magiei, el își poate trasforma mâinile în arme de corp la corp – buzdugane, topoare, ciocane.
Este bine să-l creăm mic și rapid, acest lucru îl va deosebi de golem-urile anterioare. A lovit – a
fugit, așa de ticălos e.
5. Golem din oase
Este în general inofensiv...Până când începi să-l bați. Se transformă într-un morman de oase
atunci când jucătorul crede că a câștigat...armate de schelete ies din această grămadă – ei sunt
pericolul principal, fiind înarmați cu tot ce le cade sub mâini.

Iată instrumentele pe care le avem pentru a crea noi mecanici:

- Modificare tipului de atac (de la corp la corp la distanță)
- Modificarea comportamentului (agresiv, defensiv, expectativ, mușcător)
- Modificarea dimensiunii și aspectului mișcării monstrului și viteza de atac

11
 - Adăugăm efecte
- Adăugăm stări/debuff-uri
- Dificultatea inamicului
- Noi atacuri și abilități
- Schimbarea reacției inamicului față de jucător

2.2.3. Acum vom discuta despre inamicii din joc. Pentru început aveam idea de a
introduce niște fantome drept inamici. Uitați și conceptul inamicilor dați:

Fig. 2.5 Primul concept al inamicilor

Însă conform locației fantomele nu prea se integrau în acest habitat, de aceea am luat decizia să
preschimb inamicii în alte creaturi.
Spre final, avem niște monștri violeți cu dinți enormi și fără ochi, care aleargă cu o viteză relativ
rapidă.

Fig. 2.6 Conceptul final al inamicilor

Aceștia vor fi locuitorii insulei pe care călătorește personajul nostru.

12
 2.3. Elaborarea hărții
2.3.1. Unul din aspectele principale ale unui joc este elaborarea hărții. La început se
construiește o schemă generală de dezvoltare. Toate abilitățile personajului și ordinea/locația
aproximativă în care vor fi obținute. În același timp, se discută și structura de bază a lumii. La
început este ceva simplu: configurația lumii, personajele își vor primi puterile în această ordine,
iată calea pe care o vor parcurge pentru a dobândi abilități. Apoi, în procesul de extindere a
jocului se schimbă dezvoltarea liniară a personajului și se împarte în diverse capitole.

2.3.2. Următoarea etapă constituie crearea tuturor elementor de grafică din locație,
precum ar fi copaci, iarbă, apă, cerul, nori etc.
În proiectul meu ziceam că locația este o insulă, în continuare vom vedea toate elemente de
grafică create pentru locația dată.

Aici sunt elementele pentru a construi

plăcile pe care va merge jucătorul.

Fig. 2.7 Plăci pentru teritoriu

Elementele de decor pentru a reda
atmosfera insulei. Cele mai
evidențiate sunt elementele de pe
primul plan, iar restul de pe cel
secundar.

Fig. 2.8 Palmierii

Cutiile reprezintă obstacolele peste care jucătorul va pune sări.

Fig. 2.9 Cutii

13
 2.3.3. Pentru construirea mapei, precum am menționat mai sus, vom folosi programul
Tiled. După ce importăm toate materialele necesare, putem să elaborăm primul nivel. Pentru
început vom pune punctul de start și sfârșit al nivelului.

Fig. 2.10 Punctele de control

Continuând să adăugăm elementele necesare, vom primi schema primul nivel.

Fig. 2.11 Harta primului nivel

14
3. REALIZAREA PROIECTULUI

15
3.1. Structura logică a jocului

16
 3.1.1. Pentru început vom seta acest nivel și aici avem o hartă care să ne spună unde
trebuie să fie lucrurile și, în cazul meu, am folosit doar un șir care arată așa:

Fig. 3.1
Vom parcurge acest șir pentru a obține rândul și coloana fiecărui element, apoi folosesc
informația dată pentru plasa ceva pe ecran. Codul pentru operațiunea dată arată așa:

Fig. 3.2
Mai întâi vom crea fișierul settings.py, care va conține datele despre mărimea ecranului.

Fig. 3.3
Pentru a primi înălțimea ecranului vom înmulți numărul de rânduri la mărimea unei plăci.
Creăm fișierul tiles.py, în care vom indica scriptul care va desena un pătrat gri. Apoi creăm
fișierul level.py. Lucrăm în fișierul level.py, creăm clasa Level în care vom defini metodele
necesare și vom adăuga scriptul din Fig. 3.2. Astfel la rularea programului vom primi următoarea
hartă construită din pătratele din fișierul tiles.py.

17
Fig. 3.4 Fig. 3.5
În prototip nu ajunge doar jucătorul, prin urmare vom trece la crearea acestuia, care va
reprezenta o clasă de sprite simplă pe care o vom putea deplasa. Creăm fișierul player.py în care
creăm clasa Player. Prin self.image îi dăm dimensiunea de 32x64 pixeli, self.image.fill va
răspunde de culoarea jucătorului, în cazul nostru este roșu, iar rect va răspunde de poziția
acestuia.

Fig. 3.6

Ne reîntoarcem la fișierul level.py pentru a adăuga

playerul.
Avem un singur jucător de aceea la sprite am
indicat GroupSingle().
Rezultatul:

18
Fig. 3.7 Fig. 3.8
Adăugăm variabila care răspunde de gravitație
Următorul pas este de a crea camera, pentru derularea nivelului atunci când jucătorul se mișcă.
și una pentru viteza săriturii. Definim metodele
Ne reîntoarcem la fișierul level.py și încercăm să creăm camera dată. Creăm metoda scroll_x:
date pentru jucătorul nostru. Apoi adăugăm
scriptul pentru ca săritura să se efectueze la
apăsarea tastei SPACE.

Fig. 3.9
În acest script am făcut delurarea jucătorului pe axa x, atunci când jucătorul ajunge într-o poziție
a ecranului viteza lui se egalează cu zero, în același timp se începe a derula ecranul pe axa x.
În continuare vom adăuga abilitatea jucătorului de a sări. Revenim la fișierul player.py.

Fig. 3.10 Fig. 3.11

Acum ne vom ocupa de coliziunile care se întâmplă între jucător și alte blocuri din joc. Pentru
acesta vom face următorii pași:
1. Aplicăm mișcarea verticală
2. Verificăm coliziunea verticală
3. Aplicăm mișcarea orizontală
4. Verificăm coliziunea orizontală
Revenim la fișierul level.py și începem crea cele 2 metode, una pentru mișcarea verticală, iar
cealaltă pentru cea orizontală.

19
Fig. 3.12 Fig. 3.13

20
 3.1.2. Următoarea etapă va fi să importăm personajul și să-l animăm. Revenim în fișierul
player.py și creăm metoda import_character_assets(). Creăm calea spre folderul cu imaginile
necesare. Creăm un dicționar pentru animații, care va avea următorul aspect:

Fig. 3.14
Scriem scriptul pentru a accesa imaginile pentru fiecare fișier.

Fig. 3.15
Creăm un fișier nou support.py, în care vom defini un folder de import. Pentru a importa toate
imaginile vom folosi os, acesta oferă acces la o mulțime de funcționalități, iar una dintre acestea
este posibilitatea de a alege un sistem de fișiere, metoda specifică pentru asta se numește walk.
Începem a crea bucla for pentru a stoca imaginile din fișierul corespunzător.

Fig. 3.16
Ne întoarcem în fișierul player.py. Avem toate imaginile necesare, ne rămâne doar să le punem
să meargă corespunzător într-o viteză rapidă. În metoda init am făcut niște schimbări pentru a
primi imaginea jucătorului.

Fig. 3.17
Creăm altă metodă animate(), pentru a anima jucătorul. Avem 4 animații de efectuat: idle, jump.
fall și run. Pentru a afla stare personajului vom crea metoda get_status.

21
Fig. 3.18
Rămâne doar să rezolvăm problema în care jucătorul este întors cu fața spre dreapta sau stânga.
Creăm atributul facing_right și îl adăugăm corespunzător în metode get_input.

Fig. 3.19
Paralel vom lucra și cu problema coliziunilor jucătorului cu mediul înconjurător, adăugăm câteva
varibile care ne vor ajuta să înțelegem unde se află jucătorul (on_ground, on_ceilling, on_left,
on_right).

Fig. 3.20

22
 3.1.3. Ultima ce vom mai adăuga pentru a reda viață jocului sunt efecte de particule la
diverse acțiuni. În fișierul player.py, definim metoda import_dust_run_particles(), unde vom
importa efectele de particule pentru alergare. Vom folosi același cod ca pentru animații, însă
vom face anumite schimbări. Creăm o nouă metoda run_dust_animation(), verificăm pentru
început în ce stare este jucătorul, apoi aplicăm animația, urmărind în ce direcție este poziționat
jucătorul.

Fig. 3.21

23
 3.2. Crearea unui nivel
3.2.1. Deja am vorbit despre faptul că harta nivelului o creăm în Tiled. Acum ne rămâne
să importăm totul în pygame. Pentru a importa fișierele csv, vom folosi instrumentul special în
Python cu aceiași denumire. Codul va arăta în modul dat:

Fig. 3.22
Pentru a folosi funcția dată, vom reda funcționalul ei într-un fișier aparte, support.py. Astfel, prin
funcția import_csv_layout putem importa fișierele necesare.

Fig. 3.23
Următorul pas este să aranjăm toate obiectele în pozițiile din harta creată. Dar mai întâi de toate
avem nevoie de o funcție care va tăia obiectele noastre. O vom scrie în fișierul support.py.

Fig. 3.24 Fig. 3.25

24
 3.2.2. Acum ne vom ocupa de crearea a unui health bar. În main vom adăuga 2 variabile,
una pentru valoarea maximală de health (100) și alta pentru valoarea curentă.
Vom crea un nou fișier ui.py, în care vom iniția metodele necesare pentru afișarea datelor.
Importăm aspectul grafic al health bar-ului.

Fig. 3.25
Cea mai complicată parte va fi să o facem funcționabilă, să ilustrăm cum health scade în caz de
ciocnire cu inamicii. Bara dată are lungimea de 152 px, ceea ce se egalează cu 100 din sănătatea
noastră. Trebuie să găsim raportul potrivit între valorile date când acestea se vor schimba.
În primul rând, inițializăm variabila de raport actual al sănătății, iar acestea va fi valoarea curentă
împărțită la cea totală. Apoi în variabila current_bar_width vom vedea ce lungime va avea bara
reieșind din datele curente. Exemplu:
Dacă în current_bar_width vom avea 50%, valoarea current_bar_width va fi 76 px.
Ultimul pas este de a desena bara conform datelor primite.

Fig. 3.26

25
 3.2.3. Indicatorul pentru a vedea câte monede am adunat în timpul jocului. Deasemenea,
în main vom crea variabila care va conține valoarea dată, inițial ea va fi 0. Pentru a construi
indicatorul dat, avem nevoie de un font mai specific și de o imagine a unei monede. Importăm
toate fișierele date.

Fig. 3.27
Metoda show_coins ne va ajuta să afișăm indicatorul și să desenăm font-ul necesar.

Fig. 3.28
În fișierul main.py vom crea o metodă nouă pentru a schimba valoarea indicatorului.

Fig. 3.29
În fișierul level.py, vom adăuga metoda check_coin_collisions, odată ce jucătorul se atinge de o
monedă, numărul indicatorului crește.

Fig. 3.30
Nu uităm că avem 2 tipuri de monede, aurii și argintii, prin urmare valorile lor ar trebui să fie
diferite. Ca să facem diferența între monede, le vom da valorile, pentru cele argintii – 1, iar
pentru cele aurii – 5.

Fig. 3.31

26
27
 CONCLUZII
În teza de an dată au fost obținute următoarele rezultate principale:
- A fost făcută cercetarea informațiilor necesare pentru cod și grafică. Am învățat sintaxa în
limbajul Python și biblioteca Pygame, care apoi m-au ajutat să elaborez proiectul dat. Pe
parcursul realizării proiectul am studiat noi instrumente, precum ar fi importul fișierelor csv și a
celor de tip .xml, care au fost folosite pentru elaborarea hărții și poziționarea
inamicilor/monedelor.
- A fost evidențiat mecanismul de crearea a personajelor și inamicilor. Conceptele care se
folosesc pentru a reda viața creaturilor date. Cunoștințele date m-au ajutat în elaborarea
personajelor din joc și în redarea atmosferei necesare anturajului.
- A fost realizat procesul de muncă asupra primului nivel, începând cu grafica și la sfârșit codul
și toate detaliile legate de mecanică și ciocniri. Pe parcursul perioadei date, au fost făcute multe
modificări care au ajutat la îmbunătățirea jocului și a aspectului. Astfel am primit cunoștințe noi
și m-am ciocnit cu diverse situații și greutăți.
- Părți slabe în acest proiect încă persistă, însă datorită experienței primite, sunt sigură că totul
poate fi optimizat și schimbat, pentru a primi rezultatul mai bun.
- Rezultatul obținut în cadrul tezei este o joacă 2D în baza bibliotecii PyGame, având un singur
nivel. În cadrul jocului, putem urmări schimbarea barei de sănătate și a indicatorului de monede,
care au fost un moment relativ mai complicat. Observăm grafica în stilul Pixel, desenată de la
zero și animațiile acesteia.

28
 BIBLIOGRAFIE

1. Python [citat 24.06.2022]. Disponibil la adresa electronică:

https://ru.wikipedia.org/wiki/Python#IDE

2. Biblioteca standard [citat 24.06.2022]. Disponibil la adresa electronică:

https://ru.wikipedia.org/wiki/Python#IDE

3. Python [citat 24.06.2022]. Disponibil la adresa electronică:

https://ru.wikipedia.org/wiki/Python#IDE

4. Pixel art [citat 24.06.2022]. Disponibil la adresa electronică:

https://en.wikipedia.org/wiki/Pixel_art

5. Pixel art [citat 24.06.2022]. Disponibil la adresa electronică:

https://en.wikipedia.org/wiki/Pixel_art

6. Pixel art [citat 24.06.2022]. Disponibil la adresa electronică:

https://en.wikipedia.org/wiki/Pixel_art

7. Asprite [citat 23.06.2022]. Disponibil la adresa electronică:

https://en.wikipedia.org/wiki/Aseprite

8. Tiled [citat 23.06.2022]. Disponibil la adresa electronică:

https://ru.wikipedia.org/wiki/Tiled

9. Pycharm [citat 23.06.2022]. Disponibil la adresa electronică:

https://ru.wikipedia.org/wiki/PyCharm

10. Pycharm [citat 23.06.2022]. Disponibil la adresa electronică:

https://ru.wikipedia.org/wiki/PyCharm

29
ANEXA

30