Soft Aplicativ Pentru Dezvoltarea Aptitudinilor Si Capacitatilor Intelectuale

Soft aplicativ pentru dezvoltarea aptitudinilor si capacitatilor intelectuale

„Învățătura este o comoară care își urmează stăpânul pretutindeni.”

Proverb popular

Am ales aceasta tema deoarece imi plac jocurile si limbajele de programare dar si datorita faptului ca in ultimii ani am urmat niste cursuri de programare a jocurilor video care mi-au placut.

Pentru realizarea temei ,am studiat anumite jocuri video dar si tehnicile de programare a acestora.Am ales sa folosesc programarea orientata pe obiecte deoarece cred ca este o metoda puternica de programare ,logica care se poate aplica mai ales la jocurile video deoarece jocurile video contin multe obiecte care se pot grupa usor folosind programarea orientata pe obiecte.

Ca interfata grafica,am ales sa folosesc interfata grafica WIN32 api deoarece este o interfata simpla de utilizat desi in industria jocurilor video se folosesc anumite engine-uri(motoare de programare)pentru a facilita programarea acestora.

Pe parcursul realizarii acestei teme,am intalnit numeroase dificultati (mecanicile de coliziune,efectele gravitatiei)dar care le-am solutionat citind anumite carti sau cautand pe internet.

Desi dupa jocul original care a fost foarte apreciat de public ,s-au facut mai multe copii , cred ca replica mea este una diferita si inovativa fata de celelalte pe care le-am intalnit ,si pe care intentionez sa o comercializez pe viitor.

Pe parcursul realizarii acestei teme mi-am aprofundat cunostiintele de programare..

Termenii cheie: jocuri,programare,C++,Win32,OOP

MULȚUMIRI

Doresc sa multumesc coordonatorului stiintific Prof.dr.ing Emil Petre pentru sprijinul acordat in realizarea acestei lucrari si totodata doresc sa multumesc reprezentatilor de la compania Ubisoft Craiova care au organizat in cadrul facultatii cursuri de programare a jocurilor video la care am participat.

PROLOG

CUPRINSUL

Introducere

Scopul

Primul capitol al lucrării este binențeles cel de introducere a cititorului în tema lucrării … De exemplu, acest document a fost creat cu scopul de a ajuta studenții Facultății de Automatică, Calculatoare și Electronică să își redacteze propria lucrare de licență. Acest șablon poate fi folosit de oricine respectând principiile declarate în secțiunea Error: Reference source not found.

Motivația

Autorul justifică aici alegerea și interesul său pentru tema aleasă.

NOTIUNI INTRODUCTIVE JOCURI

Jocurile sunt aplicatii software destinate distractiei. Exista mai multe categorii de jocuri printre care:

-Strategie

-Actiune

-Actiune-aventura

-Aventura

-Simulatoare

-Alte categorii(Sport, Jocuri de carti, Puzzle si altele)

In ceea ce priveste mediul de rulare a acestea pot fi pentru calculator, pentru consola, telefoane mobile si alte suporturi electronice.

Termenul joc pentru calculator se refera la un joc care presupune interactiunea dintre jucator si un calculator personal, unde monitorul este principalul mijloc de feedback, joc care foloseste ca dispozitiv de intrare fie un joystick, fie combinatia tastatura si mouse.

Termenul joc pentru consola se refera la un joc care se poate juca pe un sistem conceput special pentru acel tip de joc, unde acest sistem se poate conecta fie la un monitor fie la un televizor.

Aplicatiile pentru telefoanele mobile sunt aplicatii compatibile cu smartphone-urile, dispozitive digitale portabile, tablete, calculatoare.

Cronologie

-1950-1959

Primul joc creat a fost probabil jocul OXO de Alexander Douglas in 1952, care simuleaza jocul de X si 0. A fost o versiune de tic-tac-toe pe care l-a scris la teza de doctorat la Universitatea din Cambridge in legatura cu interactiunea dintre om si masina. Jocul era programat pe un calculator EDSAC care avea ca display un Tub catodic.

Pentru a putea juca jocul, jucatorii introduceau inputul folosind roata de la un telefon si iesirea era afisata pe un display cu Tub catodic. Fiecare joc era jucat impotriva unui jucator artificial.

Fig 1.1Jocul OXO

Fig 1.2 Echipamentul folosit pentru a rula jocul OXO(calculator EDSAC)

Totusi, majoritatea considera ca primul joc interactiv pentru calculator a fost Tennis for two dezvoltat in 1958 de fizicianul William Higginbotham cu scopul de a instrui jucatorii despre efectele gravitatiei. Jocul rula pe un computer Donner modelul 30.

Fig 2.1 Jocul Tennis for two

Fig 2.2 Echipamentul folosit pentru a rula jocul Tennis for two(calculator Donner model 30)

-1960-1969

In aceasta perioada a fost lansat jocul SpaceWar dezvoltat in 1961 de catre studentul de la MIT Steve Russel pe un calculator PDP1.

Este un joc de doua persoane, fiecare controland o nava spatiala si incercand sa distruga oponentul. Este o stea in mijlocul ecranului care atrage ambii jucatorii, acestia fiind nevoiti sa evite ciocnirea cu aceasta.

Jocul a necesitat aproximativ 200 de ore pentru a-l creea.

Fig 3.1 Jocul SpaceWar

Fig 3.2Echimpamentul necesar rularii jucului SpaceWar(calculatorul PDP1

-1970-1979

Inspirati de creatia lui Steve Russel, Nolan Brushnell impreuna cu Ted Dabney au lansat in 1971 primul joc arcade, Computer Space urmand ca imediat dupa un an sa lanseze jocul Pong, un simulator de tenis care s-a dovetit a fi un success colosal.

Fig 4.1 Masinaria Pong arcade

La scurt timp a fost creata compania Atari si au urmat o serie de jocuri. In 1978 a aparut primul joc color Space Invaders produs de catre Midway.

Scopul jocului este sa rezisti cat mai mult navelor extraterestre care vin inspre tine, avand la dispozitie un tun cu laser.

Fig 5.1 Jocul Space Invaders pe calculator

Tot in aceasta perioada a aparut si prima consola pentru jocuri, The Odyssey in anul 1972.

Succesul consolelor a inceput cu anul 1977 cand Atari a lansat consola Atari 2600.

Fig 6.1Consola Atari 2600

-1980-1989

Dupa aparitia consolei Atari 2600 au inceput sa fie portate o serie de jocuri.

Astfel in 1980 a urmat portarea jocului Space Invaders pe console.

Fig 7.1Jocul Space Invaders pe consola Atari 2600

Tot in 1980 a fost lansat un success enorm in forma jocului Pac-Man.

In acest joc, jucatorul controleaza un disc galben(Pac-Man), putandu-se misca intr-un labirint. Scopul jocului este de a manca toate bilele, incercand in acelasi timp sa nu fie mancat un alt caracter.

Fig 8.1 Jocul Pac-Man

Tot in aceasta perioada au fost lansate unele dintre cele mai importante jocuri de-alungul timpului precum Mario Bros in 1983, Final Fantasy in 1987 si Prince of Persia 1989.

In 1983 a avut loc o mare prabusire a pietei jocurilor video datorata multor jocuri aparute pe piata, piata mutandu-se de la americani la japonezi. In timp ce aceasta prabusire a distrus industria jocurilor pentru console, piata jocurilor pentru calculator nu a fost afectata aproape deloc.

In 1989 Nintendo a introdus Game Boy, prima consola portabila. Aceasta venea impreuna cu jocul Tetris, considerat cel mai dependent joc din toate timpurile.

Acesta era un joc puzzle, in care scopul este de a manipula niste figuri care cad, incercand sa le introduci in alte figuri creeind o linie orizontala fara spatii.

Fig 9.1Jocul Tetris pe consola portabila GameBoy

Fig 9.2 Consola portabila GameBoy

-1990-1999

Anii 90 au reprezentat o crestere semnificativa in industria jocurilor pentru console.

Sega a introdus Mega Drive in 1980 dupa care la scurt timp Nintendo a lansat Nintendo Super NES.

Sony a introdus Play Station in 1994, prima consola care a fost vanduta in peste 100 de milioane de exemplare.

Deoarece calculatoarele au devenit din mai puternice putand reda muzica de pe CD, au aparut o serie de jocuri cu o coloana sonora de exceptie precum Command And Conquer(1995).

Acesta a fost printre primele jocurie de strategie in timp real.

Deoarece majoritatea calculatoarelor nu puteau reda jocuri 3D s-a inceput prin “pacalirea”graficii 3D prin crearea de grafici false. Primul joc care a folosit astfel de tehnici a fost Doom creat in 1993.

Fig 10.1 Jocul Doom(1993)

Acesta a devenit cel mai popular joc din categoria first person shooter (joc de impuscaturi care intruchipeaza caracterul prin ochii lui).

-2000-2009

Dupa succesul rasunator din 1994, Sony a lansat in 2000 PlayStation 2 care la fel a fost un success enorm, dealtfel este cea mai vanduta consola ajungand la peste 150 de milioane de exemplare in 2012.

Dupa inca 6 ani, Sony a lansat a saptea generatie de console, PlayStation 3, care a fost prima consola care a introdus tehnologii cu senzori de detectare a miscarii.

In 2001 Microsoft a lansat ca raspuns la PlayStation 2, consola Xbox.

Fiind in competitive directa cu Sony, Microsoft a continuat sa lanseze console, astfel in 2005 a lansat Xbox 360.

In ceea ce priveste PlayStation 2, cel mai important joc din punct de vedere al vanzarilor a fost Grand Theft Auto: San Andreas care a ajuns la nu mai putin de 17 milioane de exemplare vandute.

In ceea ce priveste Play Station 3, cel mai vandut joc a fost Gran Turismo 5.

Si Microsoft a avut parte de incasari substantiale prin jocul Halo 2

Fig 11.1 Consola PlayStation 2 Fig 11.2 Cel mai bine vandut joc pentru consola PlayStaion2

Fig 12.1Consola PlayStation 3 Fig 12.2Cel mai vandut joc pentru consola PlayStation 3

Fig13.1Consola XBox Fig13.2Cel mai vandu joc pentru consola

-2010+

Competitia intre Microsoft si Sony a continuat, Microsoft lansand in 2013 consola Xbox One, Sony raspunzand cu consola PlayStation 4.

GENERALITATI

Introducere in limbajul de programare c++

C++ este un limbaj de programare compilat, creat pentru a scrie soft intr-o varietate de domenii. Originile acestuia sunt direct legate de predecesorul sau si anume limbajul C.

Limbajul C a aparut in 1970 fiind dezvoltat de Brian Kerningham si Dennis Ritchie. Acesta a fost creat cu scopul rescrierii sistemului de operare Unix, facandu-l disponibil pe toate platformele. Spre deosebire de alte limbaje de programare, C era un limbaj foarte flexibil permitand programarea atat la nivel inalt cat si la un nivel scazut.

Deoarece programele au devenit din ce in ce mai complexe, a fost nevoie de aparitia altor limbaje de programare, de aici pornind si ideea gruparii structurii de date dand nastere la notiunea de obiect sau clasa.

Bjarne Stroustroup a fost cel care a conceput in 1980 limbajul initial numit C with Classes(C cu Clase).

S-a inceput prin adaugarea conceptului de clasa care este caracteristica definitorie a limbajului C++, apoi au fost adaugate functiile virtuale, mostenirea multipla, sabloane(templateuri), exceptii. Standardizarea limbajului s-a facut in 1998, dar continuaindu-se dezvoltarea limbajului s-a ajuns la standardul C++ 14.

C++ a fost baza multor limbaje de programare, printre cele mai importante enumerandu-se Java si C#.

ELEMENTE FOLOSITE IN DEZVOLTAREA APLICATIEI

PROGRAMAREA ORIENTATA PE OBIECTE

Programarea orientata pe obiecte este o metoda foarte puternica de a rezolva problemele din lumea reala.

Conceptele programarii pe obiecte sunt urmatoarele:

-Clase

-Obiecte

-Incapsulare

-Abstractizare

-Polimorfism

-Mostenire

3.1.1Clase

O clasa reprezinta un tip de date definit de utilizator. Odata ce am definit o clasa, putem creea cate obiecte dorim, acestea reprezentand instante ale clasei respective.

In aceasta figura, Entitate reprezinta o clasa, iar Persoana este o instanta a clasei Entitate.

Prin definirea unei clase se specifica urmatoarele:

-numele clasei

-membrii clasei(date si functii)

-clasele de baza din care clasa e derivata(daca exista)

In acest exemplu, forma clasei va fii:

class Entitate

{

//membrii(funcii sau date)

//date

char nume;

int varsta;

int inaltime;

//functii

void afiseaza_nume();

void afiseaza_varsta();

void afiseaza_inaltime();

};Persoana

Optional, exista si etichete de permisiune(public,private,protected)astfel:

-public: membrii clasei sunt accesibili de oriunde clasa este vizibila

-private: membrii clasei sunt accesibili doar de membrii aceleiasi clase sau din clase prietene

-protected: membrii clasei sunt accesibili de membrii aceleiasi clase sau din clase prietene dar si de membrii din clasele derivate

-Membrii statici ai unei clase

Cand definim un membru static al unei clase, insteamna ca indiferent de cate obiecte ale clasei respective sunt create, exista doar o singura copie a membrului static.

Toate datele de tip static, sunt initializate cu 0 cand primul obiect este creat, daca nu exista alta initializare.

#include "stdafx.h"

#include<iostream>

using namespace std;

class cutie

{

public:

cutie()

{

static int numar=0;

numar++;

cout<<numar;

}

};

void main()

{

cutie();

cutie();

}

//Programul va afisa 12 si nu 11 deoarece numar este o variabila static,instantiata la inceput si isi retine valoarea pe parcursul mai multor apelari.

-Clase si functii friend

Functiile prietene sunt functii care pot folosii membrii privati ai unei clase, cu toate ca ele nu fac parte din clasa respectiva.

Functiile prietene se declara ca o functie normala doar ca inainte functiei au specificatorul friend.

#include "stdafx.h"

#include <iostream>

using namespace std;

class Punct

{

public:

Punct(double a, double b)

{

x=a;

y=b;

}

friend double Distanta(Punct& p1, Punct& p2);

private:

double x, y;

};

double Distanta(Punct& p1, Punct& p2)

{

double d=sqrt((p1.x-p2.x)*(p1.x-p2.x)+(p1.y-p2.y)*(p1.y-p2.y));

return d;

}

void main()

{

Punct p1(2, 2), p2(2, 2);

double d = Distanta(p1, p2);

cout << d << endl;

}

//Acest program va afisa distanta dintre cele 2 puncte p1 si p2 si anume 0

//Deoarece functia Distanta este prietena a clasei Punct ,poate sa acceseze membrii privati ai acesteia(x si y).

Similar functiilor prietene, o clasa prietena poate accesa toate datelor member protejate ale unei alte clase.

#include "stdafx.h"

#include <iostream>

using namespace std;

class Patrat;

class Dreptunghi

{

int lungime, latime;

public:

int aria ()

{

return (lungime * latime);

}

void convert (Patrat a);

};

class Patrat

{

friend class Dreptunghi;

private:

int latura;

public:

Patrat (int a)

{

latura=a;

}

};

void Dreptunghi::convert (Patrat a)

{

lungime = a.latura;

latime = a.latura;

}

int main () {

Dreptunghi dreptunghi;

Patrat patrat (4); //latura patratului este de 4

dreptunghi.convert(patrat); //lungime va deveni 4,latime va deveni 4

cout << dreptunghi.aria(); //Se va afisa aria care va fi 16

return 0;

}

-Supraincarcarea operatorilor

Prin supraincarcarea operatorilor se permite atribuirea de noi semnificatii operatorilor uzuali.De exemplu,putem folosi operatorul + si la adunarea a doua numere,si la alipirea a doua siruri,adunare de matrici etc.

Exemplu de supraincarcarea operatorului +

#include "stdafx.h"

#include <iostream>

using namespace std;

class Numar

{

public:

int x,y;

Numar()

{

x=0;

y=0;

}

Numar(int a,int b)

{

x=a;

y=b;

}

Numar operator +(Numar &rhs)

{

Numar rezultat;

rezultat.x=x+rhs.x;

rezultat.y=y+rhs.y;

return rezultat;

}

};

void main()

{

Numar x(1,2);

Numar y(2,3);

Numar z=x+y;

cout<<z.x<<' '<<z.y;

//S-a supraincarcat operatorul +.

//Se va afisa coordonatele vectorului z,coordonata x reprezentand suma coordonatelor x ale vectorilor x si y,

//coordonata y reprezentand suma cooronatelor y ale vectorilor x si y.

}

-Constructori si destructori

Constructorii sunt functii special folosite care se apeleaza automat la crearea obiectelor.Scopul acestora este de a initializa variabile

Destructorii sunt tot niste functii speciale care se apeleaza la distrugerea obiectelor si sunt folositi pentru dezalocarea memoriei.

#include "stdafx.h"

#include <iostream>

using namespace std;

class Figura

{

public:

Figura()

{

cout<<"Constructorul clasei Figura"<<endl;

}

void alfa()

{

cout<<"Metoda clasei Figura"<<endl;

}

~Figura()

{

cout<<"Destructorul clasei Figura"<<endl;

}

};

class Triunghi:public Figura

{

public:

Triunghi()

{

cout<<"Constructorul clasei Triunghi"<<endl;

}

void alfa()

{

cout<<"Metoda clasei Triunghi"<<endl;

}

~Triunghi()

{

cout<<"Destructorul clasei Triunghi"<<endl;

}

};

void main()

{

Triunghi* a=new Triunghi();

a->alfa();

delete a;

cout<<endl;

//Deoarece clasa Triunghi mosteneste clasa Figura se apeleza constructorul clasei Figura

//Se apeleaza constructorul clasei Triunghi

//a fiind un pointer la Triunghi ,se apeleaza metoda clasei Triunghi

//Se afizeaza destructorii in ordine descrescatoare:

//Destructorul clsaei Triunghi

//Destructorul clasei Figura

Figura*b=new Triunghi();

b->alfa();

delete b;

cout<<endl;

//Deoarece clasa Triunghi mosteneste clasa Figura se apeleza constructorul clasei Figura

//Se apeleaza constructorul clasei Triunghi

//b fiind un pointer la Figura ,se apeleaza metoda clasei Figura

//Se afizeaza destructorii in ordine descrescatoare:

//Destructorul clasei Figura

Figura* c =new Figura ();

c->alfa();

delete c;

cout<<endl;

//Se apeleaza constructorul clasei Figura

//c fiind un pointer la Figura ,se apeleaza metoda clasei Figura

//Se afizeaza destructorii in ordine descrescatoare:

//Destructorul clasei Figura

Triunghi d;

d.alfa();

cout<<endl;

//b fiind un obiect al clasei Triunghi iar clasa Triunghi mostenind clasa Figura

//se apeleaza constructorul clasei Figura

//Se apeleaza constructorul clsaei Triunghi

//Se apeleaza metoda clasei Triunghi

//Se afiseaza destrucorii in ordine descrescatoare:

//Destructorul clasei Triunghi

//Destructorul clasei Figura

Figura e;

e.alfa();

cout<<endl;

//b fiind un obiect al clasei Triunghi iar clasa Figura,se apeleaza constructorul clasei Figura

//Se apeleaza metoda clasei Figura

//Se afiseaza destrucorii in ordine descrescatoare:

//Destructorul clasei Figura

}

3.1.2Obiecte

Un obiect reprezinta abstractizarea unei entitati din lumea reala.Acesta contine data si functionalitate.

Poate reprezenta orice informatie care poate fi modelata.

In exemplul anterior,Persoana este un obiect al clasei Entitate.

3.1.3.Mostenirea.Clasele derivate

Mostenirea este atunci cand mai multe clase impartasesc aceeasi structura si comportament.

Clasa care mosteneste o clasa de baza poarta numele de clasa derivata.

Un obiect mostenit contine toate informatiile obiectului sau obiectelor de la care a mostenit.

Totusi este posibil daca se vrea sa se redefineasca implementarea anumitor functii mostenite.

Exista mai multe tipuri de mostenire,cele mai folosite fiind mostenirea simpla (clasa derivata mosteneste o singura clasa parinte)si cea multipla(clasa derivata mosteneste mai multe clase parinte).

Exemplu:

#include "stdafx.h"

#include <iostream>

using namespace std;

class Figura

{

public:

void setare_lungime(int l)

{

lungime=l;

}

protected:

int lungime;

};

class Patrat:public Figura

{

public:

void afiseaza_arie()

{

cout<<lungime*lungime;

}

};

void main()

{

Patrat p;

p.setare_lungime(3);

p.afiseaza_arie();

//Va afisa aria patratului si anume 9

}

3.1.4Abstractizarea

Abstractizarea reprezinta gruparea datelor si a metodelor de prelucrare specifice rezolvarii unei probleme.

typedef struct

{

int varsta;

int greutate;

}Animal;

//Animal reprezinta un tip de date abstract.

//Pentru instantierea tipului abstract Animal vom scrie:

//Animal tigru={”20”,”400”};

3.1.5Incapsularea

Incapsularea este mecanismul care leaga impreuna functiile cu membrii clasei.Acest concept defineste apartenenta unor metode si propietati fata de un obiect.Principiul incapsularii consta in a ascunde informariile specifice clasei respective de codul care va folosii aceasta clasa,expunand doar esentialul.

De ce sa folosim incapsulare?

Sa presupune ca avem doua clase A ai B.Daca un membru al clasei A este folosit de clasa B si clasa A isi modifica comportamenul,poate creea incompatibiliate cu codul clasei B.

Pentru a incapsula complet o clasa,toti membrii clasei trebuie sa fie privati.

Pentru un design de calitate,trebuie tinut cont de ce informatii sa fie accesibile si care sa fie complet ascunse.

Voi exemplifica principiul de incapsulare prin urmatorul exemplu:

//clasa care nu este incapsulata

class Femeie

{

public:

void danseaza();

char nume;

};

//clasa incapsulata

class Femeie

{

public:

void danseaza();

void denumire(char nume){m_nume=nume;}

private:

char m_nume;

};

3.1.6Polimorfism

Polimorfismul presupune o singura interfata dar mai multe implementari.De exemplu putem avea functia scade().Daca facem aceasta functie o interfata sa faca scaderea a doua numere intregi va returna diferenta celor 2 numere de tip intreg.Daca introducem doua numere reale,va returna o diferenta de tip real.Asadar ,polimorfismul ne ajuta sa accesam diferite implementari ale unei functii folosind acelasi nume.

#include "stdafx.h"

#include <iostream>

using namespace std;

class Poligon

{

protected:

int lungime, inaltime;

public:

void setare_valori (int a, int b)

{

lungime=a;

inaltime=b;

}

};

class Dreptunghi: public Poligon

{

public:

int aria()

{

return lungime*inaltime;

}

};

class Triunghi: public Poligon

{

public:

int aria()

{

return lungime*inaltime/2;

}

};

int main () {

Dreptunghi dreptunghi;

Triunghi triunghi;

Poligon * poligon1 = &dreptunghi;

Poligon * poligon2 = &triunghi;

poligon1->setare_valori (4,5);

poligon2->setare_valori (4,5);

cout << dreptunghi.aria() << '\n';

cout << triunghi.aria() << '\n';

return 0;

}

//Programul ca calcula arii dreptunghiului si aria triunghiului folosind aceeasi functie aria,evidentiind conceptul de polimorfism

//Astfel se va afisa 20 reprezentand aria dreptunghiului si 10 reprezentand aria triunghiului.

INTERFATA GRAFICA WIN32 API

Interfata grafica Windows Api este utilizata programarii aplicatiilor pentru sistemul de operare Windows.

Aceasta interfata grafica este destinata in primul rand programarii in limbajul C datorita functiilor si structurilor detaliate in C.

Desi limbajul C nu are nici o notiune de programare orientata pe obiecte ,interfata Windows Api precum si sistemul Windows au fost deseori descrise ca orientate pe obiect.

Functiile oferite de Windows Api sunt:

-Servicii de baza

Acestea permit accesul la resursele importante ale sistemului de operare.

-Servicii avansate

Permit lucrul cu registrii din Windows,stingerea-aprinderea sistemului de operare,exploatarea conturilor de utilizator.

-Interfata grafica

Aceasta interfata permite afisarea continutului grafic catre monitor,printere si alte dispozitive de iesire.

-Interfata utilizatorului

Permite crearea si exploatarea ecranului,a elementelor de baza precum butoane si scrollbaruri,permite primirea inputului mouse-ului si al tastaturii.

-Libraria de control

Permite accesul la anumite functii precum toolbarurile,taburile,barele de status.

-Libraria casutei de dialog

Este utila la afisarea casutelor de dialog in deschiderea fisierelor,inchiderea acestora,alegerea fontului,culorilor.

-Servicii pentru internet

Permit accesul la internet

-Elemente multimedia

Microsoft a oferit accesul la Directx inca din anul 1995.Acesta intefata grafica este folosita la jocuri si include:

-Direct 2D(pentru grafica 2D)

-Direct 3D(pentru grafica 3D)

-DirectSound(pentru accesul la placa de sunet)

-DirectPlay(este o librarie de comunicatie creata in special pentru jocurile video)

-DirectInput(pentru comunicatia cu dispozitivele de intrare)

4.2.1 Tipuri de date specifice Win32 API

-Handle

Este un tip generic (identificator) , utilizat pentru manipularea

obiectelor folosite în program (fișiere, ferestre, etc.). Pentru a manipula un astfel

de obiect, este necesară întâi obținerea unui asemenea HANDLE, în urma apelării

unei funcții care îl returnează. Toate operațiile ulterioare cu obiectul respectiv se

vor face prin intermediul mărimii HANDLE și nu prin intermediul numelui

obiectului respectiv. Uzual, dacă execuția funcției care returnează identificatorul

eșuează, acesta va avea valoarea NULL;

DESCRIEREA APLICATIEI

Introducere

Jocul creat este un remake al jocului Flappy Bird,un joc in care utilizatorul trebuie sa controleze o pasare,incercand sa treaca prin niste tuburi(stationare sau mobile) fara sa le atinga.

Defiecare data cand se apasa space,pasarea sare,iar atunci cand nu se apasa, aceasta cade datorita gravitatiei.

Scorul se calculeaza ca fiind numarul de tuburi trecute (neincluzant tubuzile distruse).

Jucatorul are la dispozitie o serie de abilitati pe care le primeste cand a trecut un anumit numar de tuburi.

Daca acesta considera ca jocul este prea dificil,se poate regla dificultate din meniu.

In continuare voi prezenta cum am creat acest joc,respectiv principalele functii din el.

Structura aplicatiei

Jocul a fost creat in limbajul de programare C++ ,folosind interfata grafica Windows Api(interfata grafica destinata programarii in Windows).

Ca orice joc ,contine o bucla infinita unde, in principal se executa urmatoarele 3 actiuni:

-ProcessInput (Procesare intrari), pentru detectare inputului.

-Update(Actualizare),unde se executa logica jocului

-Draw(Desenare),unde se randeaza imaginile pe ecran

Pentru cea mai buna performanta,ordinea de apelare a acestor functii este exact in aceasta ordine.

In continuare voi prezenta pe scurt fiecare dintre aceste 3 functii importante din orice joc,in cazul jocului meu.

ProcessInput(Procesare intrari)

Aceasta functie dupa cum sugereaza numele este folosita pentru detectarea si manipularea intrarilor(mouse,tastatura etc).

Aceasta functie va testa daca s-a apasat o anumita tasta sau un anumit click, daca ne aflam deasupra unui meniu anume(pentru a putea selecta ce dorim),si daca s-a selectat un meniu anume.

Practic detecteaza inputul mouse-ului si al tastaturii.

void FlappyBird::ProcessInput()

{

//Buffer pentru stocarea butoanelor

static UCHAR pKeyBuffer[ 256 ];

// Primirea starii tastaturii

if ( !GetKeyboardState ( pKeyBuffer ) )

{

return;

}

//Functie pentru verificarea butoanelor de meniu

CheckMenuButton();

//Se verifica daca s-a apasat butonul space

if (pKeyBuffer[VK_SPACE] & 0xF0)

{

//Daca s-a apasat space,pasarea sare

mPlayer->Flap();

}

}

Update(Actualizare)

In aceasta functie se executa practic logica jocului.

Aceasta contine la randul ei urmatoarele functii”

-UpdatePlayer(ActualizareJucator)

-UpdateTubes(ActualizareTuburi)

-CheckMechanics(VerificareMecanici)

-UpdateProjectiles(ActualizareProiectile)

-UpdateCoins(ActualizareMonezi)

Am ales ca toate functiile de actualizare sa contina un parametru dt(delta time),concept folosit de toti programatorii de jocuri,reprezinta timpul scurs de la ultima actualizare. Toate jocurile au nevoie de aceasta deoarece exista miscare,schimbare de pozitii,viteze etc care se schimba pentru realizarea animatiilor.

-UpdatePlayer (ActualizareJucator).

Pentru actualizarea jucatorului voi controla 3 elemente:pozitia acestuia,viteza acestuia si un element exterior si anume gravitatia .

In aceasta functie am actualizat jucatorul astfel:

-am creat un vector pentru acceleratia gravitationala,deoarece dupa cum am spus

la inceput ,la apasarea butonului space pasarea se ridica ,dupa care coboara din cauza gravitatiei.

-am modificat noua pozitie in functie de viteza curenta,acceleratia gravitationala si timpul scurs

-am modificat noua viteza in functie de acceleratia gravitationala si timpul scurs

Cu aceste 3 elemente pot actualiza jucatorul in orice moment de timp.

void FlappyBird::UpdatePlayer1(float dt)

{

Vec2 a;

// Aplic gravitatia

a.y = GRAVITATIONAL_CONSTANT * PIXEL_PER_METERS;

// Modific acceleratia tinand cont de factorii externi

a += mPlayer->mpSprite->mVelocity * (-MEDIUM_VISCOSITY);

// Actualizez pozitia si viteza imaginii

mPlayer->mpSprite->mPosition += mPlayer->mpSprite->mVelocity * dt + a * dt * dt / 2;

mPlayer->mpSprite->mVelocity += a * dt*4;

}

Fig 1.1 Fig 1.2

-UpdateTubes(ActualizareTuburi)

In ceea ce priveste tuburile,am modificat doar 1 singur element si anume viteza acestora.Deoarece ele sunt create dinainte dar nu se vad pe ecran,am modificat doar viteza cu care se indreapta spre jucator.

Pozitia acestora va depinde doar de viteza cu care se deplaseaza si de timpul scurs.

Dealtfel,toate elementele din joc pe care jucatorul nu le controleaza efectiv(precum tuburile,acestea miscandu-se cum le-am programat dar fara sa le controlez miscarea)vor avea actualizarea pozitiei in functie de viteza si timp(pozitia=viteza*dt).

In cadrul acestei functii,am parcurs toate tuburile din joc si pentru fiecare i-am actualizat noua viteza In functie de progresul jucatorului(cu cat jucatorul a avansat mai mult in joc) cu atat tuburile se deplaseaza mai repede sau au si alte miscari.

void FlappyBird::UpdateTubes(float dt)

{

// Actualizez pozitia tubului

for(int i=0;i<mTubes.size();i++)

mTubes[i]->update ( dt );

}

Fig 2.1 Fig 2.2

-UpdateCoins(ActualizareMonezi)

Deoarece la inceput in alta functie si anume BuildCoins(Creare monezi)am creat monezile la anumite coordinate si cu o anumita viteza pe axele x si y,in functia UpdateCoins(ActualizareMonezi) am actualizat noua pozitie si viteza tinand cond de pozitia curenta si timpul scurs.

Deoarece am vrut ca monezile sa se miste doar pe axa y am creat un sistem prin care atunci cand marginea de sus a monezii atinge marginea de sus a ferestrei sa-si schimbe directia ,respectiv atunci cand marginea de jos a monezii atinge marginea de jos a ferestrei sa-si schimbe directia.

Tot aici am parcurs vectorul de monezi,si pentru fiecare moneda am verificat daca a avut loc coliziune cu jucatorul si daca da atunci am eliminate-o si am actualizat scorul(scorul este format din numarul de tuburi depasite plus numarul de monezi atinse).

void FlappyBird::UpdateCoins(float dt)

{

// Functie pentru actualizarea pozitiei si vitezei monezilor

for(int i=0;i<mCoins.size();i++)

{

mCoins[i]->update ( dt );

if ((mCoins[i]->mPosition.y-mCoins[i]->GetHeight()/2<=0)||

(mCoins[i]->mPosition.y+mCoins[i]->GetHeight()/2>=512))

{

mCoins[i]->mVelocity.y=-mCoins[i]->mVelocity.y;

}

}

//Daca jucatorul atinge o moneda,scorul creste si moneda este eliminata din vector

vector<Sprite*>::iterator ia = mCoins.begin();

for(ia= mCoins.begin(); ia != mCoins.end() ; ia++)

if (Collision(mPlayer->mpSprite,*ia))

{

mPlayer->Score();

delete (*ia);

ia = mCoins.erase(ia);

}

}

Fig 3.1 Fig 3.2

-CheckMechanics(VerificareMecanici)

In aceasta functie am programat mecanicile jocului si anume:

-PlayerTubeCollision(ColiziuneaJucatorTuburi)

-Score(Sistemul de punctaj)

-RefillAmmunition(ReincarcareAmunitie)

PlayerTubeCollision(ColiziuneaJucatorTuburi)

Am folosit aceasta functie pentru a detecta coliziunile din joc.

In cadrul functiei am realizat urmatoarele:

-Am parcurs toate tuburile

-Am testat pentru fiecare tub daca a avut loc coliziunea acestuia cu pasarea

-Daca a avut loc o coliziune:

-starea jocului se schimba in starea Gameverstate(JocSfarsit).

-se pune pauza

-se reda un sunet pentru a evidentia coliziunea

Pentru a detecta coliziunea,se apeleaza o alta functie universala pentru coliziuni care functioneaza astfel:

-Functia primeste doi parametrii,reprezentand doua obiecte.

-Se salveaza cele 8 pozitii(4 pentru fiecare obiect)in felul urmator:

-Salvam partea din stanga a primului obiect (coordonatele din stanga de tot ale obiectului) ca fiind pozitia curenta(am ales pentru toate obiectele ca pozitia curenta sa fie exact in mijlocul obiectului)minus latimea obiectului impartita la 2.

-Salvam partea din dreapta a primului obiect(coordonatele din dreapta de tot ale obiectului) ca fiind pozitia curenta plus latimea obiectului impartita la 2.

-Salvam partea de sus a primului obiect(coordonatele de sus de tot ale obiectului) ca fiind pozitia curenta minus inaltimea obiectului impartita la 2.

-Salvam partea de jos a primului obiect(coordonatele de jos de tot ale obiectului) ca fiind pozitia curenta plus inaltimea obiectului impartita la 2.

Am procedat similar pentru cel de-al doilea obiect.

Avand toate aceste 8 pozitii,am calculat coliziunea in felul urmator:

-Am testat daca partea din stanga a primului obiect se suprapune peste partea din dreapta a celui de-al doilea obiect

-Am testat daca partea din dreapta a celui de-al doilea obiecte se suprapune cu partea din stanga a primului obiect

-Am testat daca partea de jos a primului obiect se suprapune cu partea de sus a celui le-al doilea obiect

-Am testat daca partea de sus a celui de-al doilea obiect se suprapune cu partea de jos a primului obiect

Daca sunt respectate toate aceste patru regului inseamna ca a avut loc o coliziune intre cele doua obiecte,deoarece coordonatele acestora se suprapun.

//Aceasta este functia generala pentru coliziuni.

int FlappyBird::Collision(Sprite*sprite1,Sprite*sprite2)

{

//Definesc cele 4 margini ale celor 2 imagini

int left1, left2;

int right1, right2;

int top1, top2;

int bottom1, bottom2;

//Salvez pozitia fiecarei margini a celeor 2 imagini care vor coliziona

//stiind ca coordonatele (0,0)reprezinta centrul imaginii

left1 = sprite1->mPosition.x-sprite1->width()/2+2;

left2 = sprite2->mPosition.x-sprite2->width()/2+2;

right1 =sprite1->mPosition.x+sprite1->width()/2-2;

right2 =sprite2->mPosition.x+sprite2->width()/2-2;

top1 = sprite1->mPosition.y-sprite1->height()/2+3;

top2 = sprite2->mPosition.y-sprite2->height()/2+3;

bottom1 = sprite1->mPosition.y+sprite1->height()/2-3;

bottom2 = sprite2->mPosition.y+sprite2->height()/2-3;

//Check for collision

if ((top1<=bottom2) &&(bottom1>=top2)&&(right1>=left2)&&(left1<=right2))

return true;

else return false;

}

//Aceasta este coliziunea pasarii cu tuburile

void FlappyBird::PlayerTubeCollision ()

{

//Pentru fiecare tub,verific daca a avut coliziune cu pasarea

for(int i=0;i<mTubes.size();i++)

//Daca a avut loc coliziune

if( Collision(mPlayer->mpSprite,mTubes[i]->m_pTube))

{

//Jocul se termina

gamestate=Gameoverstate;

//Se pune pauza

pause();

//Se reda un sunet care ne anunta ca jocul s-a terminat

PlaySound("Data/hit.wav", NULL, SND_FILENAME | SND_ASYNC);

}

}

-Score(Sistemul de punctaj)

Sistemul de punctaj este foarte simplu.

-Se parcurg toate tuburile

-Se testeaza pentru fiecare tub daca pozita pe axa orizontala a pasarii este mai mare ca pozitia tubului si nu s-a mai trecut prin acel loc,atunci scorul se mareste si se salveaza numarul de obiecte depasite pentru a stii cat s-a facut scorul(un tub trecut inseamna 1 punct).

void FlappyBird::Score ()

{

//Parcurg toate tuburile

for(int i=0;i<mTubes.size();i=i+1)

{

//Daca jucatorul e la jumatatea tubului sau mai in fata si nu a mai vizitat acel tub ,scorul creste

if (mPlayer->mpSprite->mPosition.x>

mTubes[i]->m_pTube->mPosition.x &&!score_counted[i])

{

//Salvez ,sa stim daca am vizitat tubul respectiv

score_counted[i]=true;

//Scorul creste

mPlayer->Score();

//Creste numarul de tuburi depasite

nr_of_tubes_passed++;

}

} }

Fig 4.1 Fig 4.2

RefillAmmunition(ReincarcareAmunitie)

Am introdus aceasta functie deoarece am creat un sistem prin care jucatorul are la dispozitie un anumit numar de abilitati (in acez caz dispune de “amunitie”)pe care le primeste pe masura ce avanseaza in joc.

Am stabilit ca dupa cate 10 tuburi depasite,jucatorul sa primeasca o ablilitate.

void FlappyBird::RefillAmmunition()

{

//Dupa 10 sau 11 tuburi depasite,jucatorul primeste un proiectil

if (((nr_of_tubes_passed%10==0)||((nr_of_tubes_passed-1)%10==0))&&(nr_of_tubes_passed>1))

{

//Primesc un proiectil

nr_of_projectiles++;

//Dupa fiecare proiectil primit,se reseteaza numarul de tuburi depasite pentru a relua ciclul dinnou

nr_of_tubes_passed=0;

}

}

Fig 5.1 Fig 5.2

-UpdateProjectiles(ActualizareProiectile)

Functia lucreaza in felul urmator:

-Pentru fiecare tub am verificat daca a avut loc coliziune cu “amunitia”,daca da atunci am eliminat tubul si amunitia.Daca nu se trece mai departe

-Avand o alta subfunctie care “lanseaza”aminitia si in care am specificat viteza acesteia si pozitia la lansare,am actualizat noua pozitie dupa formula pozitia=viteza*timp.

void FlappyBird::UpdateProjectiles(float dt)

{

vector<Projectile*>::iterator ii = mProjectiles.begin();

for(ii; ii != mProjectiles.end() || mProjectiles.empty(); ii++)

{

(*ii)->update(dt);

if(!mTubes.empty())

{

vector<Tube*>::iterator ia = mTubes.begin();

for(ia= mTubes.begin(); ia != mTubes.end() ; ia++)

{

if(Collision((*ia)->m_pTube,(*ii)->mProjectileSprite))

{

if ((*ii) == mProjectiles.back())

{

delete (*ia);

ia = mTubes.erase(ia);

delete (*ii);

mProjectiles.pop_back();

ii = mProjectiles.end();

break;

}

else

{

delete (*ia);

ia =mTubes.erase(ia);

delete (*ii);

ii = mProjectiles.erase(ii);

break;

}

}

}

}

if(ii != mProjectiles.end())

{

if (!mBoardBounds.IsPtInside((*ii)->mProjectileSprite->mPosition))

{

delete (*ii);

ii = mProjectiles.erase(ii);

if(ii == mProjectiles.end())

break;

}

}

else

{

break;

}

}

}

Cea de-a treia functie importanta in orice joc dupa cum am mai spus este functia Draw(Desenare sau Randare).

Pentru un design mai frumos si o refolosire mai usoara a codului,am grupat mai multe tipuri de desenari astfel:

void FlappyBird :: draw ( HDC hBackBufferDC, HDC hSpriteDC )

{

//In fuunctie de starea actuala,desenez ceva

switch(gamestate)

{

case Gameplaystate:

//Desenez elementele legate de gameplay

DrawGameplay (hBackBufferDC,hSpriteDC );

break;

case Menustate:

//Desenez meniul(butoanele de meniu)

DrawMenu(hBackBufferDC,hSpriteDC );

break;

case Submenustate:

//Desenez submeniul(butoanele de submeniu)

DrawSubMenu(hBackBufferDC,hSpriteDC );

break;

case Gameoverstate:

//Desenez elementele cand se termina jocul(butoane,imagini)

DrawGameOver(hBackBufferDC,hSpriteDC );

break;

case DifficultyMenuState:

//Desezez meniul de dificultati

DrawDifficultyMenu(hBackBufferDC,hSpriteDC );

break;

}

}

-DrawGameplay

Aici am desenat toate elementele din timpul jocului(caractere,fundal,mediu etc).

Mai specific,am desenat tuburile,pasarea,fundalul,proiectilele,scorul,monezile.

void FlappyBird::DrawGameplay(HDC hBackBufferDC, HDC hSpriteDC)

{

//Desenez imaginea de fundal

mParallaxLayer->draw ( hBackBufferDC, hSpriteDC );

//Desenez tuburile

for ( int i = 0; i < mTubes.size(); i++ )

{

mTubes[i]->draw ( hBackBufferDC, hSpriteDC );

}

//Desenez pasarea

mPlayer->draw ( hBackBufferDC, hSpriteDC );

//Desenez proiectilele

for ( int i = 0; i < mProjectiles.size(); i++ )

{

mProjectiles[i]->draw( hBackBufferDC, hSpriteDC );

}

//Pentru performanta,nu voi desena monezile in afara ferestrei

for ( int i = 0; i < mCoins.size(); i++ )

{

if ((mCoins[i]->mPosition.y+mCoins[i]->GetWidth()/2>0)&&

(mCoins[i]->mPosition.y-mCoins[i]->GetWidth()/2<512))

mCoins[i]->draw ( hBackBufferDC, hSpriteDC );

}

//Desenare diferite texte

char nrofprojectiles[32];

SetTextColor ( hBackBufferDC, RGB ( 0, 0, 128 ) );

SetBkMode ( hBackBufferDC, TRANSPARENT );

sprintf_s ( nrofprojectiles, "Projectiles = %d",nr_of_projectiles );

TextOut ( hBackBufferDC, 10, 30, nrofprojectiles, ( int ) strlen ( nrofprojectiles ) );

char dif[32];

SetTextColor ( hBackBufferDC, RGB ( 0, 0, 128 ) );

SetBkMode ( hBackBufferDC, TRANSPARENT );

if (difficulty==Difficulty::Easy)

sprintf_s ( dif, "Difficulty: Easy");

else

if (difficulty==Difficulty::Normal)

sprintf_s ( dif, "Difficulty: Normal");

else

if (difficulty==Difficulty::Hard)

sprintf_s ( dif, "Difficulty: Hard");

TextOut ( hBackBufferDC, 10, 50, dif, ( int ) strlen ( dif ) );

}

Fig 6.1

In aceasta figura am evidentiat faptul ca in aceasta functie se deseneaza toate elementele din joc.

-DrawMenu

Aici am desene doar meniul

void FlappyBird::DrawMenu(HDC hBackBufferDC,HDC hSpriteDC )

{

//Desenez fundalul cu meniul

mMenu->draw ( hBackBufferDC, hSpriteDC );

//Desenez butoanele din meniu

switch(SinglePlayerButton)

{

case Button::Normal:

mButton[Button::SINGLEPLAYER_NORMAL]->draw ( hBackBufferDC, hSpriteDC );

break;

case Button::Highlighted:

mButton[Button::SINGLEPLAYER_HIGHLIGHTED]->draw ( hBackBufferDC, hSpriteDC );

break;

case Button::Pressed:

mButton[Button::SINGLEPLAYER_PRESSED]->draw ( hBackBufferDC, hSpriteDC );

break;

}

switch(QuitButton)

{

case Button::Normal:

mButton[Button::QUIT_NORMAL]->draw ( hBackBufferDC, hSpriteDC );

break;

case Button::Highlighted:

mButton[Button::QUIT_HIGHLIGHTED]->draw ( hBackBufferDC, hSpriteDC );

break;

case Button::Pressed:

mButton[Button::QUIT_PRESSED]->draw ( hBackBufferDC, hSpriteDC );

break;

}

switch(ScoresButton)

{

case Button::Normal:

mButton[Button::SCORES_NORMAL]->draw ( hBackBufferDC, hSpriteDC );

break;

case Button::Highlighted:

mButton[Button::SCORES_HIGHLIGHTED]->draw ( hBackBufferDC, hSpriteDC );

break;

case Button::Pressed:

mButton[Button::SCORES_PRESSED]->draw ( hBackBufferDC, hSpriteDC );

break;

}

switch(DifficultyButton)

{

case Button::Normal:

mButton[Button::DIFFICULTY_NORMAL]->draw ( hBackBufferDC, hSpriteDC );

break;

case Button::Highlighted:

mButton[Button::DIFFICULTY_HIGHLIGHTED]->draw ( hBackBufferDC, hSpriteDC );

break;

case Button::Pressed:

mButton[Button::DIFFICULTY_PRESSED]->draw ( hBackBufferDC, hSpriteDC );

break;

}

}

Fig 7.1

-DrawSubmenu

Aici am desenat doar submmeniurile

void FlappyBird::DrawSubMenu(HDC hBackBufferDC, HDC hSpriteDC)

{

//Desenez butoanele din submeniu

switch(QuitButton)

{

case Button::Normal:

mButton[Button::QUIT_NORMAL]->draw ( hBackBufferDC, hSpriteDC );

break;

case Button::Highlighted:

mButton[Button::QUIT_HIGHLIGHTED]->draw ( hBackBufferDC, hSpriteDC );

break;

case Button::Pressed:

mButton[Button::QUIT_PRESSED]->draw ( hBackBufferDC, hSpriteDC );

break;

}

switch(BackToMenuButton)

{

case Button::Normal:

mButton[Button::BACK_NORMAL]->draw ( hBackBufferDC, hSpriteDC );

break;

case Button::Highlighted:

mButton[Button::BACK_HIGHLIGHTED]->draw ( hBackBufferDC, hSpriteDC );

break;

case Button::Pressed:

mButton[Button::BACK_PRESSED]->draw ( hBackBufferDC, hSpriteDC );

break;

}

switch(ResumeButton)

{

case Button::Normal:

mButton[Button::RESUME_NORMAL]->draw ( hBackBufferDC, hSpriteDC );

break;

case Button::Highlighted:

mButton[Button::RESUME_HIGHLIGHTED]->draw ( hBackBufferDC, hSpriteDC );

break;

case Button::Pressed:

mButton[Button::RESUME_PRESSED]->draw ( hBackBufferDC, hSpriteDC );

break;

}

switch(SinglePlayerButton)

{

case Button::Normal:

mButton[Button::SINGLEPLAYER_NORMAL]->draw ( hBackBufferDC, hSpriteDC );

break;

case Button::Highlighted:

mButton[Button::SINGLEPLAYER_HIGHLIGHTED]->draw ( hBackBufferDC, hSpriteDC );

break;

case Button::Pressed:

mButton[Button::SINGLEPLAYER_PRESSED]->draw ( hBackBufferDC, hSpriteDC );

break;

}

}

-DrawGameover

Aici am desemat elementele ce apar in momentul in care jocul se terminat(mesaje de final,imagini).

void FlappyBird::DrawGameOver( HDC hBackBufferDC, HDC hSpriteDC )

{

//Desenez fundalul atunci cand jocul se termina

mGameOver->draw ( hBackBufferDC, hSpriteDC );

//Desenez butoanele cand jocul se termina

switch(QuitButton)

{

case Button::Normal:

mButton[Button::QUIT_NORMAL]->draw ( hBackBufferDC, hSpriteDC );

break;

case Button::Highlighted:

mButton[Button::QUIT_HIGHLIGHTED]->draw ( hBackBufferDC, hSpriteDC );

break;

case Button::Pressed:

mButton[Button::QUIT_PRESSED]->draw ( hBackBufferDC, hSpriteDC );

break;

}

switch(BackToMenuButton)

{

case Button::Normal:

mButton[Button::BACK_NORMAL]->draw ( hBackBufferDC, hSpriteDC );

break;

case Button::Highlighted:

mButton[Button::BACK_HIGHLIGHTED]->draw ( hBackBufferDC, hSpriteDC );

break;

case Button::Pressed:

mButton[Button::BACK_PRESSED]->draw ( hBackBufferDC, hSpriteDC );

break;

}

switch(SinglePlayerButton)

{

case Button::Normal:

mButton[Button::SINGLEPLAYER_NORMAL]->draw ( hBackBufferDC, hSpriteDC );

break;

case Button::Highlighted:

mButton[Button::SINGLEPLAYER_HIGHLIGHTED]->draw ( hBackBufferDC, hSpriteDC );

break;

case Button::Pressed:

mButton[Button::SINGLEPLAYER_PRESSED]->draw ( hBackBufferDC, hSpriteDC );

break;

}

}

-DrawDifficultymenu

In aceasta zona am desenat cele trei butoane cu dificultatile(easy,normal,hard).

Dupa cum sugereaza si numele,am ales sa randez pe ecran imaginile in functie de starea actuala in care ne aflam(in meniu,in joc efectiv,submeniuri.final etc).

void FlappyBird::DrawDifficultyMenu(HDC hBackBufferDC,HDC hSpriteDC )

{

//Desenez fundalul meniului de dificultati

mMenu->draw ( hBackBufferDC, hSpriteDC );

//Desenez butoanele meniului de dificultati

switch(EasyDifficultyButton)

{

case Button::Normal:

mButton[Button::EASY_NORMAL]->draw ( hBackBufferDC, hSpriteDC );

break;

case Button::Highlighted:

mButton[Button::EASY_HIGHLIGHTED]->draw ( hBackBufferDC, hSpriteDC );

break;

case Button::Pressed:

mButton[Button::EASY_PRESSED]->draw ( hBackBufferDC, hSpriteDC );

break;

}

switch(NormalDifficultyButton)

{

case Button::Normal:

mButton[Button::NORMAL_NORMAL]->draw ( hBackBufferDC, hSpriteDC );

break;

case Button::Highlighted:

mButton[Button::NORMAL_HIGHLIGHTED]->draw ( hBackBufferDC, hSpriteDC );

break;

case Button::Pressed:

mButton[Button::NORMAL_PRESSED]->draw ( hBackBufferDC, hSpriteDC );

break;

}

switch(HardDifficultyButton)

{

case Button::Normal:

mButton[Button::HARD_NORMAL]->draw ( hBackBufferDC, hSpriteDC );

break;

case Button::Highlighted:

mButton[Button::HARD_HIGHLIGHTED]->draw ( hBackBufferDC, hSpriteDC );

break;

case Button::Pressed:

mButton[Button::HARD_PRESSED]->draw ( hBackBufferDC, hSpriteDC );

break;

}

}

Pe langa aceste trei functii de le-am discutat(ProcessInput,Update si Draw) am folosit in constructorul jocului functii pentru crearea obiectelor si pentru initializarea variabilelor astfel:

In functia Init(Initializare) am initializat toate variabilele necesare precum:

-variabile pentru a stii daca jocul a fost pus pe “pauza”

-variabile necesare in detectare mouse-ului(sa stim daca s-a apasat mouse-ul,daca s-a eliberat clickul,sa stim ultima oara cand s-a apasat)

-un vector in care am salvat scorurile

-un timer necesar pentru a reda anumite sunete cand doresc eu

-numarul de proiectile disponibile

-coordonatele ecranului pentru a stii daca am deposit ecranul

-distanta dintre tuburi

-numarul de tuburi peste care am trecut

void FlappyBird::Init()

{

// La inceput jocul este pus pe pauza

mPaused = true;

//Variabile pentru detectarea inputului mouseului

KeyReleased=false;

LastFrame = false;

KeyDown = false;

//Vector cu dimensiunea tuburilor

//La inceput nici un tub nu a fost parcurs deci initializez elementele vectorului cu false

score_counted.resize(mTubes.size());

for(int i=0;i<score_counted.size();i++)

score_counted[i]=false;

//Timer pentru verificarea anumitor actiuni( momentul pornirii sunetului etc)

mtimer=0;

//Jucatorul porneste cu un proiectil la inceput

nr_of_projectiles=1;

//Marginile ferestrei(folositoare pentre stergerea obiectelor care nu se mai afla in fereasta de joc)

mBoardBounds = Rect ( 0, 0, 1366, 768 );

//La inceput,jucatorul nu a depasit nici un tub

nr_of_tubes_passed=0;

//La inceput dificultatea este setata automat pe easy

gap=75;

}

Tot in constructorul jocului,am apelat functia BuildObjects(CreareObiecte)care contine:

-fundalul

-tuburile

-pasarea

-monezile

-butoanele(meniurile)

Pentru simplitate obiectele au fost create in functii diferite si toate aceste functii au fost incluse intr-o functie principal de creare a obiectelor.

//Aceasta este functia unde am creat toate obiectele

void FlappyBird::BuildObjects()

{

BuildBackgrounds();

BuildTubes();

BuildButtons();

BuildPlayer();

}

In ceea ce priveste butoanele,acestea au 3 stari pentru a evidentia cand s-a apasat,cand se tine deasupra unui buton sau cand s-a eliberat butonul.Acestea le-am creat la coronate stabilite de mine,respective un buton sub altul.

//Aceasta este functie pentru crearea butoanelor

void FlappyBird::BuildButtons()

{

mButton[Button::SINGLEPLAYER_NORMAL]=new Button(mhAppInst,Button::SinglePlayer,Button::Normal);

mButton[Button::SINGLEPLAYER_HIGHLIGHTED]=new Button(mhAppInst,Button::SinglePlayer,Button::Highlighted);

mButton[Button::SINGLEPLAYER_PRESSED]=new Button(mhAppInst,Button::SinglePlayer,Button::Pressed);

mButton[Button::QUIT_NORMAL]=new Button(mhAppInst,Button::Quit,Button::Normal);

mButton[Button::QUIT_HIGHLIGHTED]=new Button(mhAppInst,Button::Quit,Button::Highlighted);

mButton[Button::QUIT_PRESSED]=new Button(mhAppInst,Button::Quit,Button::Pressed);

mButton[Button::BACK_NORMAL]=new Button(mhAppInst,Button::BackToMenu,Button::Normal);

mButton[Button::BACK_HIGHLIGHTED]=new Button(mhAppInst,Button::BackToMenu,Button::Highlighted);

mButton[Button::BACK_PRESSED]=new Button(mhAppInst,Button::BackToMenu,Button::Pressed);

mButton[Button::RESUME_NORMAL]=new Button(mhAppInst,Button::Resume,Button::Normal);

mButton[Button::RESUME_HIGHLIGHTED]=new Button(mhAppInst,Button::Resume,Button::Highlighted);

mButton[Button::RESUME_PRESSED]=new Button(mhAppInst,Button::Resume,Button::Pressed);

mButton[Button::SCORES_NORMAL]=new Button(mhAppInst,Button::Scores,Button::Normal);

mButton[Button::SCORES_HIGHLIGHTED]=new Button(mhAppInst,Button::Scores,Button::Highlighted);

mButton[Button::SCORES_PRESSED]=new Button(mhAppInst,Button::Scores,Button::Pressed);

mButton[Button::DIFFICULTY_NORMAL]=new Button(mhAppInst,Button::Difficulty,Button::Normal);

mButton[Button::DIFFICULTY_HIGHLIGHTED]=new Button(mhAppInst,Button::Difficulty,Button::Highlighted);

mButton[Button::DIFFICULTY_PRESSED]=new Button(mhAppInst,Button::Difficulty,Button::Pressed);

mButton[Button::NORMAL_NORMAL]=new Button(mhAppInst,Button::NormalDifficulty,Button::Normal);

mButton[Button::NORMAL_HIGHLIGHTED]=new Button(mhAppInst,Button::NormalDifficulty,Button::Highlighted);

mButton[Button::NORMAL_PRESSED]=new Button(mhAppInst,Button::NormalDifficulty,Button::Pressed);

mButton[Button::HARD_NORMAL]=new Button(mhAppInst,Button::HardDifficulty,Button::Normal);

mButton[Button::HARD_HIGHLIGHTED]=new Button(mhAppInst,Button::HardDifficulty,Button::Highlighted);

mButton[Button::HARD_PRESSED]=new Button(mhAppInst,Button::HardDifficulty,Button::Pressed);

mButton[Button::EASY_NORMAL]=new Button(mhAppInst,Button::EasyDifficulty,Button::Normal);

mButton[Button::EASY_HIGHLIGHTED]=new Button(mhAppInst,Button::EasyDifficulty,Button::Highlighted);

mButton[Button::EASY_PRESSED]=new Button(mhAppInst,Button::EasyDifficulty,Button::Pressed);

}

In ceea ce priveste monezile,am inceput prin a le creea la o pozitie aleasa de mine pe axa orizontala.

Urmatoarele monezi le-am creat la distante egale intre ele pe axa orizontala dar pe axa vericala le-am dat o coordonata aleatoare doarece monezile le voi misca pe axa verticala.

//Functia pentru crearea monezilor

void FlappyBird::BuildCoins()

{

//a+rand()%(b+1-a) genereaza un numar aleator cuprins intre a si b.

srand(time(0));

int coin_x_pos;

int coin_y_pos;

//Pozitia orizontala a primei monezi

coin_x_pos=500;

int i=0;

//Numarul monezilor este egal cu numarul tuburilor

for(i=0;i<mTubes.size()*2;i++)

{

//Pozitie aleatoare cu coordonate intre 20 490

coin_y_pos =20+rand()%(471);

p0=Vec2(float(coin_x_pos),float( coin_y_pos));

//Setez viteza monezii egale cu cea a tubului pentru a parea ca monezile nu se misca in fata,doar in sus si jos

v0.x=-110;

//Viteza aleatoare pe axa y intre -20 and 20

v0.y=-50;

mCoin = new Sprite ( mhAppInst, IDB_COIN, IDB_COIN_MASK,p0,v0);

mCoins.push_back(mCoin);

//Pozitia orizontala a urmatoarei monezi

coin_x_pos=coin_x_pos+200;

}

}

In ceea ce priveste tuburile aceastea le-am pus unu peste altul,distanta dintre ele pe axa verticala fiind legata de dificultatea aleasa(cu cat dificultatea este mai mare ,cu atat distanta dintre ele este mai mica).

Am pornit de la o pozitie aleasa.In functie de acea pozitie am creat tuburi la distante egale intre ele pe axa orizontala plasate aleatoriu.

De exemplu primul tub l-am plasat la pozitiile 400 pe axa orizontala.

Urmatorul l-am creat la o pozitie aleatoare dar cuprinsa intre anumite coordinate astfel:

pozitie_verticala=-150+rand()%(100+150)

Aceasta expresie imi plaseaza tubul la coordinate cuprinse intre -150 si 99

Generic:

a+rand()%(b+1-a) genereaza un numar aleator cuprins intre a si b.

//Functia pentru crearea tuburilor

void FlappyBird::BuildTubes()

{

//In functie de nivelul de dificultate ,schimb distanta dintre tuburi

if (difficulty==Difficulty::Hard)

gap=75;

else

if (difficulty==Difficulty::Normal)

gap=80;

else

if (difficulty==Difficulty::Easy)

gap=85;

srand(time(0));

//Pozitia orizontala a primului tub

int top_tube_vertical_pos;

int bottom_tube_vertical_pos;

//Toate tuburile de sus au aceasta pozitie orizontala

int top_tube_horizontal_pos=400;

//Toata tuburile de jos au aceasta pozitie orizontala

int botoom_tube_horizontal_pos=400;

int i=0;

//Tuburi de nivelul 1(tuburi care stau pe loc)

for(i=0;i<5;i++)

{

//Pozitie verticala aleatoare cu coordonate -150 and 150

top_tube_vertical_pos =-150+rand()%(100+150);

//Pozitia finala a tubului(orizontala si vericala) p0=Vec2(float(top_tube_horizontal_pos),float( top_tube_vertical_pos));

//Creez tubul de sus la aceasta pozitie

mTube=new Tube( mhAppInst,Tube::Tube_Down,p0);

//Salvez tubul intr-un vector

mTubes.push_back(mTube);

//Deoarece stiu pozitia tubului de sus,cea a tubului de jos va fi cea a tubului de sus adunat cu inaltimea tubului si cu distanta care o doresc intre cele doua

bottom_tube_vertical_pos = top_tube_vertical_pos+tube_height+gap;

//Pozitia finala(verticala si orizontala)

p0=Vec2(float(botoom_tube_horizontal_pos),float(bottom_tube_vertical_pos));

//Creez tubul de sus la aceasta pozitie

mTube=new Tube( mhAppInst,Tube::Tube_Up,p0);

//Salvez tubul in vector

mTubes.push_back(mTube);

//Pozitia orizontala si verticala a urmatorului tub

top_tube_horizontal_pos=top_tube_horizontal_pos+200;

botoom_tube_horizontal_pos=botoom_tube_horizontal_pos+200;

}

//Tuburi de nivelul 2(care se misca in sus)

//Sunt create dupa aceleasi principii ca cele de nivelul 1

for(i=0;i<10;i++)

{

top_tube_vertical_pos =-150+rand()%(100+150);

p0=Vec2(float(top_tube_horizontal_pos),float( top_tube_vertical_pos));

mTube=new Tube( mhAppInst,Tube::Tube_Down,p0);

mTubes.push_back(mTube);

mTube->setlevel(2);

bottom_tube_vertical_pos = top_tube_vertical_pos+tube_height+gap;

p0=Vec2(float(botoom_tube_horizontal_pos),float(bottom_tube_vertical_pos));

mTube=new Tube( mhAppInst,Tube::Tube_Up,p0);

mTubes.push_back(mTube);

mTube->setlevel(2);

top_tube_horizontal_pos=top_tube_horizontal_pos+200;

botoom_tube_horizontal_pos=botoom_tube_horizontal_pos+200;

}

//Tuburi de nivelul 3(care se misca in jos)

//Sunt create dupa aceleasi principii ca cele de nivelul 1

for(i=0;i<10;i++)

{

top_tube_vertical_pos =-150+rand()%(100+150);

p0=Vec2(float(top_tube_horizontal_pos),float( top_tube_vertical_pos));

mTube=new Tube( mhAppInst,Tube::Tube_Down,p0);

mTubes.push_back(mTube);

mTube->setlevel(3);

bottom_tube_vertical_pos = top_tube_vertical_pos+tube_height+gap;

p0=Vec2(float(botoom_tube_horizontal_pos),float(bottom_tube_vertical_pos));

mTube=new Tube( mhAppInst,Tube::Tube_Up,p0);

mTubes.push_back(mTube);

mTube->setlevel(3);

top_tube_horizontal_pos=top_tube_horizontal_pos+200;

botoom_tube_horizontal_pos=botoom_tube_horizontal_pos+200;

}

//Tuburi de nivelul 4(care se misca in sus si jos aleator)

//Sunt create dupa aceleasi principii ca cele de nivelul 1

for(i=0;i<10;i++)

{

int k=0+rand()%5;

top_tube_vertical_pos =-150+rand()%(100+150);

p0=Vec2(float(top_tube_horizontal_pos),float( top_tube_vertical_pos));

mTube=new Tube( mhAppInst,Tube::Tube_Down,p0);

mTubes.push_back(mTube);

mTube->setlevel(4);

mTube->setrandomlevel(k);

bottom_tube_vertical_pos = top_tube_vertical_pos+tube_height+gap;

p0=Vec2(float(botoom_tube_horizontal_pos),float(bottom_tube_vertical_pos));

mTube=new Tube( mhAppInst,Tube::Tube_Up,p0);

mTubes.push_back(mTube);

mTube->setlevel(4);

mTube->setrandomlevel(k);

top_tube_horizontal_pos=top_tube_horizontal_pos+200;

botoom_tube_horizontal_pos=botoom_tube_horizontal_pos+200;

}

}

Pentru creare fundalului si am ales mijlocul ecranului pentru a centra imaginea.

//Functia pentru crearea imaginilor de fundal

void FlappyBird::BuildBackgrounds()

{

//Dimensiunea ferestrei de joc

const int gClientWidth = 800;

const int gClientHeight = 512;

//Centrul ferestrei

const POINT wndCenterPt = { gClientWidth / 2, gClientHeight / 2 };

p0 = wndCenterPt;

//Creez imaginea de meniu

mMenu = new Sprite ( mhAppInst, IDB_MENUSCREEN, IDB_MENUSCREEN_MASK,p0 );

//Creeze imaginea de terminare a jocului

mGameOver = new Sprite(mhAppInst, IDB_GAMEOVER, IDB_GAMEOVER_MASK,p0 );

p0 = wndCenterPt;

//Creez fundalul

mParallaxLayer=new ParallaxLayer(mhAppInst,p0);

mParallaxLayer->Move(ParallaxLayer::DIR_RIGHT);

}

La crearea jucatorului nu a fost nevoie decat de pozitia initiala a acestuia data in constructor.Tot in constructor am selectat viteza initiala a pasarii deoarece aceasta este afectata de gravitatie.

//Functia pentru crearea jucatorului(pasarii)

void FlappyBird::BuildPlayer()

{

mPlayer=new Player( mhAppInst);

}

Ca orice aplicatie continand clase,va avea un constructor si un destructor pentru a elibera memoria.

//Constructorul jocului

FlappyBird :: FlappyBird ( HINSTANCE hAppInst, HWND hMainWnd, Vec2 wndCenterPt ):

tube_height(500)

{

// Parametrii de intrare

mhAppInst = hAppInst;

mhMainWnd = hMainWnd;

mWndCenterPt=wndCenterPt;

//Se apeleaza functia pentru initializare

Init();

//Se creeaza obiectele

BuildObjects();

}

//Destructorul pentru stergerea tuturor obiectelor

FlappyBird :: ~FlappyBird ( void )

{

delete mGameBoard;

delete mPlayer;

delete mMenu;

delete mGameOver;

for(std::map<Button::Buttons,Button*>::iterator MapItor = mButton.begin(); MapItor != mButton.end(); ++MapItor)

{

Button* Value = MapItor->second;

delete Value;

}

mButton.clear();

while(!mTubes.empty()) delete mTubes.back(),mTubes.pop_back();

while(!mCoins.empty()) delete mCoins.back(),mCoins.pop_back();

delete mParallaxLayer;

while(!mProjectiles.empty()) delete mProjectiles.back(), mProjectiles.pop_back();

}

Deoarece am dat posibilitatea jucatorului sa puna pauza in timpul jocului,am creat urmatoarele functii:

pause(pauza),pentru a pune pauza

void FlappyBird :: pause ( void )

{ //Daca ma aflu in stare de joc,imediat dupa pauza schimb starea in starea de submeniu

if (gamestate==Gameplaystate)

{

mPaused = true;

showCursor(true);

gamestate=Submenustate;

}

//Cand jocul se termina,doresc sa fie trecut in pauza.

//Dar punandu-l in pauza se intoarce la starea de submmeniu

//Pentru a rezolva aceasta,testez daca ma aflu intr-o stare diferita de joc

//Astfel se trece pe pauza fara a trece in starea de submeniu

if (gamestate!=Gameplaystate)

{

mPaused = true;

showCursor(true);

}

}

unpause(reluare),pentru a continua jocul

void FlappyBird :: unpause ( void )

{ //Nu doresc ca butonul de reluare,sa fie verificat cand jocul s-a terminat sau este in starea de meniu pentru ca nu este nevoie

if ((gamestate!=Menustate) && (gamestate!=Gameoverstate))

{

mPaused = false;

showCursor(false);

gamestate=Gameplaystate;

}

}

Functia pause(pauza) pentru a pune pauza am realizat-o astfel:

-Am testat daca ma aflu in joc(daca nu ma aflu in joc nu am practic la ce sa pun pauza).Daca da,variabila care tine cont daca s-a pus pauza se face true,se afiseaza cursorul si se schimba starea jocului in submeniustate(submeniu)

-Daca starea jocului este diferita de gameplaystate(starea cand efectiv ma aflu in joc ,nu in meniu sau altundeva), variabila care tine cont daca s-a pus pauza se face true,se afiseaza cursorul dar starea ramane aceeasi.

Am facut aceasta deoarece cand jocul s-a terminat de exemplu,as vrea automat sa se puna pe pauza.Dar punandu-l pe pauza ,automat m-ar trece in stare de submeniu ceea ce nu vreau.

Functia unpause (continuare,reluare) am creat-o dupa principiul

-Daca nu ma aflu in meniu sau in stare de joc terminat,functia este valida,astfel variabila care tine cont de pauza se face false,cursorul se ascunde,si stare se schimba in gameplaystate(starea de joc)

Am gandit in acest fel deoarece nu vreau sa mi se dea voie sa reiau(sa continui de unde am ramas) jocul cand ma aflu in meniu(nu am ce relua in meniu evident) sau dupa ce jocul s-a terminat(trebuie inceput altul deci nu se mai poate continua jocul current).Vrea doar sa pot contina jocul cand efectiv interactionez cu jocul.

Ca orice joc,la inceput cand se incepe un joc nou trebuie sa resetez totul.Astfel am creat o functie ResetGame(ResetareJoc) in care am apelat:

-functia de initializare

-am sters pasarea

-am creat din nou pasarea

-am sters tuburile

-am creat din nou tuburile

-am eliberat vectorul de proiectile

//Functia pentru resetarea tuturo elementelor din joc

void FlappyBird::ResetGame()

{

//Resetare variabile

Init();

//Se sterge obiectul jucator

delete mPlayer;

//Se creaza obiectul jucator

BuildPlayer();

//Se sterg obiectele reprezentand tuburi

while(!mTubes.empty()) delete mTubes.back(), mTubes.pop_back();

//Se creaza obiectele reprezentand tuburi

BuildTubes();

//Se sterg monezile

while(!mCoins.empty()) delete mCoins.back(), mCoins.pop_back();

//Se creaza monezile

BuildCoins();

//Se sterg proiectilele

while(!mProjectiles.empty()) delete mProjectiles.back(), mProjectiles.pop_back();

}

Pentru afisarea si ascunderea cursorului am creat urmatoare functie car functioneaza astfel:

-Se afiseaza cursorul pana cand counterul(o variabila care se incrementeaza sau decrementeaza la apelarea functiei ShowCursor din Windows)devine mai mic ca 0.

–Se ascunde cursorul pana cand counterul(o variabila care se incrementeaza sau decrementeaza la apelarea functiei ShowCursor din Windows)devine mai mare sau egal ca 0.

//Functia pentru afisarea si ascunderea cursorului

//Cursorul este afisat pana cand counterul este mai mic ca 0

//Cursorul este ascuns pana cand counterul este mai mare sau egal ca 0.

//Fac asta deoarece defiecaredata cand apelez functia ShowCursor() din windows,o valuare se incrementeaza sau decrementeaza.

//De exemplu daca vreau sa afisez cursorul apeland functia ShowCurosr(true) de 2 ori la rand,counterul va trece de la 0 la 2.

//Daca dupa aceea doresc sa ascund cursorul apeland functia ShowCursor(false),counterul va deveni 1.

//Deoarece este 1 si nu este mai mic ca 0 nu va ascunde cursorul

//Efectiv imbunatatesc functia de afisare si ascundere a cursorului din windows.

void FlappyBird::showCursor(bool show)

{

if (show)

while (ShowCursor(TRUE) < 0);

else

while (ShowCursor(FALSE) >= 0);

}

In ceea ce priveste modul de detectara a pozitiei mouse-ului am creat urmatoare functie

care functioneaza astfel:

-Functia primeste ca parametru obiectul a carei pozitie dorim sa o detectam

-Cu ajutoru comenzii din Windows GetCursorPos()primesc coordonatele curente al mouse-ului.

-Stiind pozitia curenta si pozitia obiectului am calculat pozitiile care limiteaza obiectul

-Am testat daca mouse-ul se afla in aceste pozitii,daca da atunci ma aflu pe obiect,daca nu sunt in afara obiectului

//Functia pentru testarea daca mouseul este deasupra unei imagini

bool FlappyBird::OnMouseOver ( Sprite *spr )

{

POINT p;

//Pozitia cursorului,representata de punctul p cu coordonatele x si y

GetCursorPos ( &p );

//Raportez pozitia mouseului la client.

ScreenToClient ( mhMainWnd, &p );

//Testez daca coordonatele cursorului sunt in interiorul coordonatelor imaginii

if ( ( p.x + spr->width() / 2 > spr->mPosition.x ) &&

( p.x < spr->mPosition.x + spr->width() / 2 ) &&

( p.y + spr->height() / 2 > spr->mPosition.y ) &&

( p.y < spr->mPosition.y + spr->height() / 2 ) )

return true;

else

return false;

}

Fig 9.1 Fig 9.2

Pentru a evidentia functia care am creat-o pentru a detecta input-ului mouse-ului am facut doua printuri,astfel in figura 9.1 am evidentiat mouse-ul in afara unei imaginii iar in figura 9.2 in interiorul acesteia.

CONCLUZII

BIBLIOGRAFIE

Curs POO 2010 – Prof.dr.ing. Emil Petre

An Overview of the C++ Programming Language-Bjarne Stroustrup

OBJECT ORIENTED PROGRAMMING WITH C++- P. B. Kotur

Object Oriented Programming Using C++ and Java- Ramesh Vasappanavara

REFERINTE WEB

http://en.wikipedia.org/wiki/C%2B%2B

http://en.wikibooks.org/wiki/C++_Programming/Programming_Languages/Paradigms/Encapsulation

http://ro.wikipedia.org/wiki/Joc_video

http://inventors.about.com/library/inventors/blcomputer_videogames.htm

http://en.wikipedia.org/wiki/Windows_API

http://ro.wikipedia.org/wiki/Windows_API

http://bigfoot.cs.upt.ro/~cami/upc/cpp.html

http://en.wikipedia.org/wiki/C%2B%2B_classes

http://www.elcom.pub.ro/discipline/poo/laborator/Lucrarea%20nr.%203.pdf

http://en.wikipedia.org/wiki/Spacewar_%28video_game%29

http://www.cs.uu.nl/docs/vakken/b2go/literature/history_of_games.pdf

http://en.wikipedia.org/wiki/Pong

http://infoap.utcluj.ro/wincpp/cap02/Cap2.pdf

A. CD / DVD

Autorul atașează în această anexă obligatorie, versiunea electronică a aplicației, a acestei lucrări, precum și prezentarea finală a tezei.

Index

B

Bibliografie 9

C

CUPRINSUL xi

D

Dimensiuni 3

F

Figuri 4

Formulele matematice 4

I

Ilustrațiile 4

L

Legenda 6

LISTA FIGURILOR xii

LISTA TABELELOR xiii

R

Referințe web 10

S

Structura documentului 2

T

Tabele 5