UNIVERSITATEA „ALEXANDRU IOAN CUZA” IAŞI

FACULTATEA DE INFORMATICĂ

LUCRARE DE LICENŢĂ

Blackjack – Aplicație Android

Propusă de

Patraș G. Florentin-Gabriel

Sesiunea: Februarie, 2017

Coordonator știinţific

Asistent, dr. Vasile Alaiba

UNIVERSITATEA „ALEXANDRU IOAN CUZA” DIN IAȘI

FACULTATEA DE INFORMATICĂ

LUCRARE DE LICENȚĂ

Blackjack – Aplicație Android

Patraș G. Florentin-Gabriel

Sesiunea: Februarie 2017

Coordonator știinţific

Asistent, dr. Vasile Alaiba

DECLARAŢIE PRIVIND ORIGINALITATEA ŞI RESPECTAREA

DREPTURILOR DE AUTOR

Prin prezenta declar că Lucrarea de licenţă cu titlul „Blackjack – Aplicație Android” este

scrisă de mine şi nu a mai fost prezentată niciodată la o altă facultate sau instituţie de învăţământ

superior din ţară sau străinătate.

De asemenea, declar că toate sursele utilizate, inclusiv cele preluate de pe Internet, sunt

indicate în lucrare, cu respectarea regulilor de evitare a plagiatului:

− toate fragmentele de text reproduse exact, chiar şi în traducere proprie din altă limbă,

sunt scrise între ghilimele şi deţin referinţa precisă a sursei;

− reformularea în cuvinte proprii a textelor scrise de către alţi autori deţine referinţa

precisă;

− codul sursă, imaginile etc. preluate din proiecte opensource sau alte surse sunt utilizate

cu respectarea drepturilor de autor şi deţin referinţe precise;

− rezumarea ideilor altor autori precizează referinţa precisă la textul original.

Iași, Absolvent Patraș Florentin-Gabriel

_________________

DECLARAŢIE DE CONSIMŢĂMÂNT

Prin prezenta declar că sunt de acord ca Lucrarea de licență cu titlul „Blackjack –

Aplicație Android”, codul sursă al programelor şi celelalte conţinuturi (grafice, multimedia, date

de test etc.) care însoţesc această lucrare să fie utilizate în cadrul Facultăţii de Informatică.

De asemenea, sunt de acord ca Facultatea de Informatică de la Universitatea „Alexandru

Ioan Cuza” Iași să utilizeze, modifice, reproducă şi să distribuie în scopuri necomerciale

programelecalculator, format executabil şi sursă, realizate de mine în cadrul prezentei lucrări de

licenţă.

Iași, Absolvent Patraș Florentin-Gabriel

_________________

1

Cuprins

1. Introducere ......................................................................................................... 3

1.1. Motivație ....................................................................................................... 3

1.2. Context .......................................................................................................... 4

1.3. Cerințe funcționale ...................................................................................... 5

1.4. Tehnologii utilizate ...................................................................................... 5

2. Structura aplicației ............................................................................................ 9

2.2. Android Manifest .........................................................................................12

3. Blackjack ..........................................................................................................13

3.1. Descriere .......................................................................................................13

3.2. Reguli ............................................................................................................14

3.3. Implementare ...............................................................................................15

3.3.1. Clasa jucător ..........................................................................................15

3.3.2. Clasa carte ..............................................................................................16

3.3.3. Clasa blackjack ......................................................................................16

3.3.3. Pachetul de cărți ....................................................................................17

3.3.4. Amestecarea pachetului de cărți ..........................................................18

3.3.5. Jocul ........................................................................................................19

3.3.6. Sistemul de câștig sau pierdere ............................................................23

3.3.7. Clasa DBSql ............................................................................................24

4. Interfața și activitate ........................................................................................27

4.1. Iconița aplicație ..........................................................................................28

4.2. Meniul principal ........................................................................................29

4.3. Activitatea Blackjack ................................................................................30

4.4. Activitatea cadou .......................................................................................33

4.5. Activitatea ajutor .......................................................................................35

4.6. Activitatea statistici ...................................................................................35

2

4.7. Butonul ieșire .............................................................................................36

5. Strategii pentru câștig .....................................................................................37

6. Concluzii ...........................................................................................................38

7. Direcții de dezvoltare .......................................................................................39

8. Bibliografie .......................................................................................................40

3

1. Introducere

1.1. Motivație

Blackjack – Aplicație Android este un joc disponibil pe platforma Android

în care este disponibil jocul douăzeci și una dintr-un cazinou. Jocul va putea fi

jucat de un singur jucător și nu va avea nevoie de conexiune la internet. Jucătorul

va începe cu un număr de fise predefinit cu care se va putea juca. Jucătorul poate

vedea statistici despre joc: numărul jocurilor pierdute/câștigate și balanța fiselor.

Numărul de fise și detalii despre numărul de jocuri jucate va fi salvat. Fiecare joc

va avea un ghid în care se explică regulile și posibilele câștiguri.

Am ales această temă deoarece este un joc interesant, care poate aduce

câștiguri utilizatorului. Pentru a satisface această dorință de a jucat am dorit să fac

o aplicație pe platforma Android.

Am ales platforma Android deoarece este lider pe piață la ora actuală după

cum se poate observa în figura 1 și aș dori să am un număr cât mai mare de

utilizatori.

4

1

Figura 1. Piața sistemelor de operare a telefoanelor inteligente

1.2. Context

Domeniul jocurilor de noroc se află în plină dezvoltare în momentul acesta. În

ultima perioadă, în România, majoritatea agențiilor de pariuri și-au făcut platforme

1 http://www.idc.com/promo/smartphone-market-share/os;jsessionid=22F13B94A15E97A1FFA2EA1B9E73B1D8

5

pe internet de pariere și puține dintre ele au aplicații mobile. Acestea conțin

evenimente sportive pe care putem paria și în puține cazuri jocuri de noroc. De

exemplu ele pot conține următoarele jocuri: Blackjack, Slot, Poker, Bingo.

Două aplicații mobile foarte bune sunt cele de la Unibet și Betano. Cei de la

Unibet au foarte multe aplicații disponibile pentru fiecare sport în parte. În plus au

aplicații pentru jocurile din cazinou și pentru poker. În schimb cei de la Betano au

aplicații la fel de performante, dar sunt disponibile doar pentru utilizatorii iOS.

La polul opus, sunt aplicații mobile care au neajunsuri. Aceste aplicații nu au o

interfață ușor de înțeles, consumă multe resurse sau nu oferă stabilitate. Aplicațiile

de acest tip sunt utilizate cu greu de utilizatori.

1.3. Cerințe funcționale

Jucarea jocului Blackjack.

Vizualizarea numărului de jocuri câștigate sau pierdute, a numărului

de fise jucate sau câștigate și a unei balanțe.

Utilizatorul va primi un număr de fise la un anumit interval de timp pe

care îl va putea colecta.

Vizualizarea ghidului pentru joc. În acest ghid sunt disponibile

regulile jocului și potențialele câștiguri.

1.4. Tehnologii utilizate

Android este o platformă software și un sistem de operare pentru telefoanele

mobile bazată pe nucleul Linux. Această platformă a fost dezvoltată de Google.

Google a cumpărat Android, care era o mică companie cu sediul la Palo Alto,

California, Statele Unite ale Americii. După achiziționarea companiei Android,

cofondatorii acesteia au continuat să muncească la Google. Mai târziu platforma

6

Android a fost dezvoltată de Open Handset Alliance. Android folosește limbajul

Java, iar prin intermediul bibliotecilor Java dezvoltate de Google sunt gestionate

dispozitivele. Aplicațiile pot fi scrise și în limbajul C compilate și executate în cod

mașină ARM, dar Google nu oferă sprijin oficial în acest sens.2

Limbajul de programare Java este un limbaj de programare orientat-

obiect, care se bazează pe moștenire, încapsulare, polimorfism, conceput de James

Gosling la Sun Microsystems lansat în anul 1995. Limbajul Java preia o parte din

sintaxă de la C și C++. Caracteristici complicate precum moștenirea multiplă,

șabloanele prezente în alte limbajele de programare sunt eliminate. Java folosește

administrarea automată a memoriei, astfel pointerii sunt eliminați. Astfel apare

„colectorul de gunoi” care șterge obiectele care numai sunt utilizate. Un program

Java compilat poate fi rulat pe orice platformă pe care este instalată o mașină

virtuală Java. Acest lucru este posibil deoarece sursele Java sunt compilate într-un

format standard numit cod de octeți(figura 2). Java asigură o performanță ridicată a

codului de octeți care este intermediar între codul mașină și codul sursă. 3

2 https://ro.wikipedia.org/wiki/Android_(sistem_de_operare)#Platforme_Android

3 https://ro.wikipedia.org/wiki/Java_(limbaj_de_programare)

7

4

Figura 2. Compilator Java

SQLite este o bază de date cu sursă deschisă. SQLite este o mică bibliotecă C

care implementează un motor de baze de date SQL încapsulat, oferă posibilitatea

de a-l introduce în diverse sisteme și necesită zero-configurare. SQLite suportă

tipuri de date Text, Integer și Real. Înainte de a introduce datele în baza de date

acestea trebuie convertite în aceste tipuri. SQLite este instalat în fiecare dispozitiv

Android, nefiind necesar o procedură de instalare sau de administrare a bazei de

date. Trebuie numai să definească instrucțiunile SQL pentru crearea și actualizarea

bazei de date. După aceea, baza de date este gestionat automat de platforma

Android.5

4 https://www.safaribooksonline.com/library/view/client-server-web-apps/9781449369323/ch04.html

5 https://ro.wikipedia.org/wiki/SQLite

8

SQLite este ușor de folosit, foarte sigur și rapid, dar trebuie folosit atunci când

folosim baze de date mai simple. Dacă avem baze de date complexe nu este indicat

să folosim SQLite. Informațiile din baza de date reprezintă un singur fișier. Cât

timp fișierul și directorul în care se află permit scrierea și citirea, atunci se poate

schimba, adăuga și șterge orice din baza de date SQLite. Poate fi folosit cu ușurință

pentru aplicațiile de pe dispozitivele mobile.

Codul sursă pentru SQLite este de domeniu public. Nu există nici o pretenție de

drept de autor pe nici o parte din codul sursă de bază. Toți cei care au contribuit la

crearea nucleului SQLite au semnat că nu au nici un interes pentru drepturile de

autor asupra codului. Acest lucrul înseamnă că orice poate să folosească codul

sursă SQLite.

SQLite este optimizat pentru dimensiune. El având o dimensiune redusă,

întreaga librărie cu toate opțiunile activate are dimensiunea mai mică de 225KiO.

Această dimensiune poate fi mai mică dacă se dezactivează opțiunile care nu sunt

necesare, iar mărimea librărie poate ajunge la sub 170KiO. Celelalte baze de date

SQL sunt mult mai mari decât SQLite.6

Android Studio este mediul oficial de dezvoltare a aplicațiilor pe platforma

Android. Aceasta funcționează bazat pe JetBrains IDEA IntelliJ. Android Studio a

fost lansat pe 16 mai 2013 la o conferință Google și este disponibil gratuit sub

licența Apache 2.0.7

6 https://ro.wikipedia.org/wiki/SQLite

7 https://en.wikipedia.org/wiki/Android_Studio

9

2. Structura aplicației

Arhitectura aplicației este conține aplicația Blackjack și o bază de date locală

pentru salvarea diferitelor informații despre istoricul jocurilor.

Figura 3. Arhitectura aplicației

Structura aplicației constă în următoarele fișiere:

Un fișier AndroidManifest.xml cu exact acest nume în care se află

informațiile pentru sistemul Android despre conținutul aplicației.

Fișierele sursă Java în care se pot afla clase, activități sau

implementări a unor diferite interfețe.

În res/drawable va conține fișierele sursă a unor imagini. Android

suportă următoarele tipuri de extensii a imaginilor: JPEG, PNG, BMP,

GIF. În cazul nostru acolo avem cele 52 de cărți din pachetul de joc,

imaginile pentru fundal și iconița aplicației.

În res/layout se află interfețele care comunică cu utilizatorul. În cazul

nostru activate principală se află în activity_main.xml.

10

Figura 4. Structura aplicației

Principale clase ale aplicației sunt Jucător, Cărți și Blackjack, iar relațiile

dintre ele sunt prezentate în imaginea următoare.

11

Figura 5. Diagrama claselor

Baza de date SQLite este formată dintr-o singură tabelă și va fi folosită

pentru păstrarea datelor despre jocuri. Această tabelă va avea o singură

înregistrare.

Figura 6. Diagrama bazei de date SQLite

Jucătorul după ce a intrat în joc poate face următoarele operații:

Să joace Blackjack;

Să primească un cadou la un anumit interval de timp;

Să vizualizeze regulile jocului;

Să se uite peste statistici;

Să părăsească jocul.

12

Figura 7. Diagrama de cazuri

2.2. Android Manifest

În fiecare aplicație Android există un fișier cu numele AndroidManifest.xml

care oferă sistemului Android informații importante pentru rularea codului.

Informații precum numele pachetelor Java, activitățile pe care le face aplicația,

procesele care găzduiesc aplicația se regăsesc în acest fișier. În cazul nostru avem

în fișier informații despre activitățile posibile ale aplicației. Fiecare activitate va

avea orientare setată portret.8

8 https://developer.android.com/guide/topics/manifest/manifest-intro.html

13

3. Blackjack

3.1. Descriere

Blackjack-ul, cunoscut ca și douăzeci și una, este un joc de cărți în care

jucătorul va concura împotriva dealerului. Poate fi jucat cu unu sau mai multe

pachete de cărți, iar fiecare carte are o anumită valoare după cum se poate vedea în

figura 8. 9

10

Figura 8. Valorile cărților

Obiectivul jocului de blackjack este atingerea unui scor cât mai apropiat de

21. Acest lucru trebuie realizat fără a depăși această valoare, în caz contrar mâna

fiind considerată pierdută. Dacă nu ajungi la 21, obiectivul jocului este să obții un

scor mai mare decât al dealerului.

9 https://en.wikipedia.org/wiki/Blackjack

10 https://www.pokerstarscasino.ro/games/blackjack/

14

3.2. Reguli

La începutul fiecărei runde jucătorul va plasa o miza pe care va juca. După

plasarea mizei, dealerul împarte câte 2 cărți jucătorului și 2 cărți lui. Cărțile

jucătorului vor fi cu fața în sus, iar dealerul va avea doar o carte cu fața în sus.

Acuma că s-au împărțit cărțile jucătorul are următoarele opțiuni: Hit, Stand,

Double, Split, Surrender, Insurance.

Hit: jucătorul alege să mai tragă o carte.

Stand: jucătorul alege să se oprească.

Double: jucătorul alege să mai tragă o singură carte și să dubleze miza

jucată inițial.

Split: dacă jucătorul primește două cărți cu aceeași valoare, el poate să le

împartă în două mâini separate. Atunci dealerul separă cărțile și le mai adaugă încă

o carte, iar fiecare mână va avea miza inițială. Jucătorul va putea câștiga sau pierde

fiecare mână, deoarece aceste mâini sunt independente.

Surrender: jucătorul poate alege să se „predea” și va primi înapoi doar

jumătate din miza inițială. Acest lucru este posibil doar după împărțirea primelor

două cărți.

Insurance: dacă carte dealerul întoarsă cu fața în sus este as, jucătorul va

putea pune o miza că următoarea carte va avea valoare 10, atunci dealerul va avea

Blackjack. Pariul este tratat independent și este plătit 2:1.

Mâna în care se realizează 21 din două cărți este mai puternică decât mâna

în care se realizează 21 din trei sau mai multe cărți. În caz de egalitate câștigă

mâna cu valoarea 21 din două cărți.

La sfârșitul rundei jucătorul poate câștiga sau pierde astfel:

Dacă jucătorul depășește 21 el va pierde automat miza plasată.

Dacă jucătorul are valoarea cărților mai mică decât a dealerului atunci

el va pierde miza.

Dacă jucătorul este la egalitate cu dealerul, atunci el va primi înapoi

miza.

15

Dacă jucătorul are valoarea cărților mai mare decât a dealerului,

atunci el va câștiga în raport de 2:1 miza.

Dacă dealerul depășește 21 și jucătorul nu depășește 21 atunci el va

câștiga în raport de 2:1 miza.

Dacă jucătorul realizează 21 din două cărți, respectiv un as plus o altă

carte în valoare de 10, atunci el va câștiga în raport de 3:2 miza.

3.3. Implementare

3.3.1. Clasa jucător

Clasa jucător este clasa în care vom avea informațiile despre jocurile

utilizatorului pe care le-am jucat până în momentul curent. Prima dată când

utilizatorul va juca acest joc clasa va folosi constructorul Jucator(int f). Utilizatorul

va începe cu un număr de fise predefinit.

public class Jucator

int jocuriJucateB;

int jocuriCastigateB;

int jocuriJucateS;

int jocuriCastigateS;

int fise;

Jucator(int f)

fise = f;

this.jocuriJucateB = 0;

this.jocuriCastigateB = 0;

this.jocuriJucateS = 0;

this.jocuriCastigateS = 0;

Această clasă mai conține două metode prin care se adaugă sau scade fise

jucătorului.

16

3.3.2. Clasa carte

În clasa carte vom crea obiecte pentru pachetul de cărți. Aici se vor afla

informații despre valoare fiecărei cărți, tipul cărții și imaginea specifică fiecărei

cărți. Variabila tip are două întrebuințări va memora tipul cărții și adăugând la ea o

extensie pentru imagine vom obține imaginea specifică. Această clasă arată astfel:

public class Carte

int valoare;

String tip;

Carte(int val, String t)

this.valoare = val;

this.tip = t;

3.3.3. Clasa blackjack

Clasa blackjack este clasa în care va fi creat jocul blackjack. În această clasa

vom creat pachetul de cărți și mediul pentru jucarea de Blackjack. În această clasa

vom avea următorii parametrii: miza pentru un joc de Blackjack și un obiect din

clasa jucător. Această clasă arată astfel:

public class Blackjack

int miza;

Jucator player;

Blackjack(int m, Jucator juc)

this.miza = m;

this.player = juc;

17

3.3.3. Pachetul de cărți

Pentru a memora pachetul de cărți am folosit clasa Vector. Clasa Vector este o

mulțime de obiecte care poate crește sau scădea după necesitate. Elementele din

mulțime poate fi accesate după un index.

De la platforma Java 2 v1.2, această clasă a fost montată ulterior pentru a pune

în aplicare interfața List, făcându-l un membru al cadrului Java Colecții. Clasa

Vector conține metode mai vechi, care nu fac parte din cadrul Java Colecții. 11

Vectorul va fi declarat de dimensiune 52, deoarece un pachet de cărți are 52 de

cărți fără Jokeri, care nu sunt necesari la acest joc. Implementarea creării pachetul

de cărți este:

Vector<Carte> pachetAmestecat()

Vector<Carte> carti = new Vector<Carte>(52);

int val = 2, val2 = 2;

for(int i = 0; i < 12; ++i)

carti.add(new Carte(val, "inima" + val2));

carti.add(new Carte(val, "romb" + val2));

carti.add(new Carte(val, "cruce" + val2));

carti.add(new Carte(val, "frunza" + val2));

if(val < 10)

val++;

val2++;

11

https://docs.oracle.com/javase/7/docs/api/java/util/Vector.html

18

carti.add(new Carte(11, "inima14"));

carti.add(new Carte(11, "romb14"));

carti.add(new Carte(11, "cruce14"));

carti.add(new Carte(11, "frunza14"));

try

Collections.shuffle(carti);

catch(UnsupportedOperationException e)

return carti;

Acum fiecare carte din pachet este creată. De exemplu cartea Jack de inimă

va fi reprezentată prin obiectul Carte(10, ”inima11”). Asul am ales să ia valoare

11, iar mai târziu acesta va lua valoarea 1 dacă suma totală a cărților din mâna

depășește 21.

3.3.4. Amestecarea pachetului de cărți

Clasa Collections este alcătuită din metode statice care fac operații pe liste

sau returnează liste. Aceasta conține algoritmi specifici pentru colecții, care

returnează o nouă colecție susținută de o colecție specificată și alte câteva

mărunțișuri. Deoarece clasa Vector face parte din colecții voi punea folosi această

clasa. Din această clasă voi avea nevoie de metoda public static void

shuffle(List<?> list). Metoda are nevoie de un parametru, lista care va fi

amestecată. Această metodă aruncă o excepție UnsupportedOperationException în

cazul în care nu este posibilă această operație pe lista trimisă ca parametru.

19

Această metodă mută aleator elementele din listă cu un număr aleator prestabilit.

Toate mutările au o probabilitate egală.12

Această implementare traversează lista înapoi, de la ultimul element până la

al doilea, schimbând în mod repetat, un element selectat aleatoriu în "poziția

curentă". Metodă se execută într-un timp liniar.

3.3.5. Jocul

În acest moment avem pregătit pachetul de cărți amestecat și începem să

împărțim cărțile către utilizator și dealer, fiecare primind câte două cărți. Cărțile

vor fi împărțite una câte una de la 0 la 51.

Vector<Carte> pachet = this.pachetAmestecat();

int i = 0;

Vector<Carte> dealer = new Vector<Carte>(11);

Vector<Carte> jucator = new Vector<Carte>(11);

jucator.add(pachet.get(i));

i++;

dealer.add(pachet.get(i));

i++;

jucator.add(pachet.get(i));

i++;

dealer.add(pachet.get(i));

i++;

În acest moment dacă jucătorul ajunge la punctajul de 21 nu va putea face

nimic decât să aștepte ca dealerul să termine și mâna lui. Dacă nu are punctajul de

21 atunci el va putea facă următoarele mutări:

Double: să mai tragă o singură carte și miza se va dubla.

Surrender: să renunțe la mâna lui și va primii înapoi doar jumătate din miza. 12

https://docs.oracle.com/javase/6/docs/api/java/util/Collections.html

20

Aceste două mutări, Double și Surrender, se pot realiza doar după împărțirea

primelor două cărți.

Split: dacă valoarea primelor două cărți este egală atunci utilizatorul poate

împărți mâna în două mâini separate. Cea de-a doua mână va primi o carte din

prima mână, se elimină cartea respectivă din prima mână, după care se continuă cu

cărți din pachet. Implementarea arată astfel:

jucator2.add(jucator.get(1));

jucator.remove(1);

jucator.add(pachet.get(i));

i++;

jucator2.add(pachet.get(i));

i++;

Hit: jucătorul mai extrage o carte. El va putea face acest lucru până când

realizează 21 sau depășește acestă valoare. Pentru acest lucru avem nevoie de două

metode.

Metoda countAs va număra câți ași sunt în mâna jucătorului, deoarece asul

este o carte specială care poate lua valoarea 1 sau 11. Inițial el va avea valoare 11,

dar dacă suma totală a cărților din mână depășește valoare de 21 el va avea valoare

1.

int countAs(Vector<Carte> car)

int count = 0;

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

if(car.get(i).valoare == 11)

count++;

return count;

21

int sumaCarti(Vector<Carte> car)

int suma = 0;

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

suma += car.get(i).valoare;

int count = countAs(car);

if(count > 0 )

//doar un as

if(suma > 21 && count==1)

suma -= 10;

//doar doi asi

if(suma > 21 && count==2)

suma -= 10;

if(suma > 21)

suma -= 10;

//doar trei asi

if(suma > 21 && count==3)

suma -= 10;

if(suma > 21)

suma -= 10;

22

if(suma > 21)

suma -= 10;

//doar patru asi

if(suma > 21 && count==4)

suma -= 10;

if(suma > 21)

suma -= 10;

if(suma > 21)

suma -= 10;

if(suma > 21)

suma -= 10;

return suma;

Stand: jucătorul se poate opri oricând dorește să mai extragă altă carte.

Dealerul pe de altă parte este nevoit să extragă cărți până ajunge la un

punctaj de cel puțin 17, iar dacă depășește 21 el pierde.

23

while(sumaCarti(dealer) < 17)

dealer.add(pachet.get(i));

i++;

3.3.6. Sistemul de câștig sau pierdere

Utilizatorul poate câștiga în următoarele cazuri:

dacă realiza 21 din două cărți și dealerul nu atunci el va primi

miza în valoare de 3:2;

if(sumJucator == 21 && jucator.size() == 2 && !(sumDealer == 21 &&

dealer.size()==2))

this.player.adauga(this.miza * 2 + (this.miza / 2));

dacă suma cărților este mai mare ca suma cărților dealerului,

dar ambele nu depășesc 21 în raport de 2:1;

if(sumJucator < 22 && sumDealer < 22 && sumJucator > sumDealer)

this.player.adauga(this.miza * 2);

dacă dealerul depășește 21 și utilizatorul nu atunci el câștiga în

raport de 2:1.

if(sumDealer >= 22 && sumJucator <22)

this.player.adauga(this.miza * 2);

Utilizatorul poate pierde în următoarele cazuri:

dacă depășește 21 el pierde automat;

dacă suma cărților este mai mică ca suma cărților dealerului, dar

ambele nu depășesc 21 atunci el pierde;

if(sumJucator < 22 && sumDealer < 22 && sumJucator < sumDealer)

// a pierdut miza inițială

24

daca atât dealerul cât și jucătorul depășesc 21 atunci jucătorul va

pierde.

În cazul în care utilizatorul și dealerul au același punctaj mizele

sunt returnate.

3.3.7. Clasa DBSql

Clasa DBSql extinde SQLiteOpenHelper prin ajutorul căreia se face

conexiunea la baza de date, crearea bazei de date și executarea de interogări asupra

tabelei în care se află statisticile despre jocurile jucate până în momentul respectiv.

SQLiteOpenHelper este o clasă care ne vine în ajutor pentru gestionarea

bazei de date. Această clasă necesită două metode abstracte pentru punerea sa în

aplicare. Cele două metode sunt OnCreate() și OnUpgrade(). Aceste două metode

vor fi apelate în funcție de starea bazei de date, dacă este creată, dacă nu este creată

sau dacă necesită modificări.13

Metoda OnCreate() este folosită pentru crearea bazei de date.

@Override

public void onCreate(SQLiteDatabase db)

db.execSQL("create table salvare " +

"(id integer primary key," +

"fise integer," +

"jocuriB integer," +

"jocuriBw integer," +

"jocuriS integer," +

"jocuriSw integer," +

"totalFise integer," +

"totalFiseW integer)"

);

13

https://developer.android.com/reference/android/database/sqlite/SQLiteOpenHelper.html

25

Metoda OnUpgrade() este folosită în cazul în care baza de date are nevoie de

modificări.

@Override

public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion)

db.execSQL("DROP TABLE IF EXISTS salvare");

onCreate(db);

Pe lângă aceste metode mai sunt metode care mă ajută la obținerea

înregistrărilor, adăugarea, modificarea sau ștergerea înregistrărilor din baza de

date. Pentru a face acest lucru avem nevoie de două metode. Metodele sunt

getWritableDatabase() și getReadableDatabase().

Metoda getWritableDatabase() va deschide sau crea o bază de date pentru

operațiile de scriere sau citire. Prima oară când se va încerca deschiderea bazei de

date se vor folosi metodele OnUpgrade() sau OnCreate(). După ce s-a deschis cu

succes baza de date va fi stocată în memoria cache, putând fi folosită această

metodă ori de câte ori este nevoie.

Metoda getReadableDatabase() returnează ca metoda de mai sus, dar pot

apărea situații de excepție în care se va deschide baza de date doar pentru operații

de citire.14

Metoda pentru adăugarea unei înregistrări este următoarea:

public boolean insertSalvare (int fise, int jocuriB, int jocuriBw, int totalFise, int totalFiseW)

SQLiteDatabase db = this.getWritableDatabase();

ContentValues contentValues = new ContentValues();

contentValues.put("fise", fise);

contentValues.put("jocuriB", jocuriB);

contentValues.put("jocuriBw", jocuriBw);

contentValues.put("totalFise", totalFise);

contentValues.put("totalFiseW", totalFiseW);

db.insert("salvare", null, contentValues);

return true;

14

https://developer.android.com/reference/android/database/sqlite/SQLiteOpenHelper.html

26

Metoda pentru modificarea unei înregistrări este următoarea:

public boolean updateSalvare (int id, int fise, int jocuriB, int jocuriBw, int totalFise, int

totalFiseW)

SQLiteDatabase db = this.getWritableDatabase();

ContentValues contentValues = new ContentValues();

contentValues.put("fise", fise);

contentValues.put("jocuriB", jocuriB);

contentValues.put("jocuriBw", jocuriBw);

contentValues.put("totalFise", totalFise);

contentValues.put("totalFiseW", totalFiseW);

db.update("salvare", contentValues, "id = ? ", new String[]Integer.toString(id));

return true;

Metoda pentru ștergerea unei înregistrări este următoarea:

public Integer deleteSalvare (Integer id)

SQLiteDatabase db = this.getWritableDatabase();

return db.delete("salvare",

"id = ? ",

new String[]Integer.toString(id));

Metoda pentru obținerea unei înregistrări este următoarea:

public Cursor getData(int id)

SQLiteDatabase db = this.getReadableDatabase();

Cursor res = db.rawQuery( "select * from salvare where id="+id+"", null );

return res;

27

4. Interfața și activitate

Interfața în Android este foarte importantă deoarece facilitează comunicare cu

utilizatorul. Ele sunt de forma unor scheme care definesc structura vizuală a

interfeței. Aceste interfețe sunt de forma unor XML-uri. XML-urile sunt

asemănătoare cu crearea paginilor web în HTML în care adăugam elemente cu

ajutorul marcajelor. Fiecare schemă a unui XML trebuie să conțină exact o

rădăcină la care pot adaugă alte elementele ca copiii. Pentru fiecare schemă XML

va fi implementată o activitate nouă.

15

Figura 9. Structura unei scheme XML

Activitatea este un singur lucrul pe care îl poate face la un moment dat și ele

interacționează cu utilizatorul. Ciclu de viață a unei activități este prezentat în

figura 10.

15

https://developer.android.com/guide/topics/ui/declaring-layout.html

28

16

Figura 10. Ciclul de viață a unei activități

4.1. Iconița aplicație

Iconiță aplicație este foarte importantă deoarece trebuie să fie

reprezentativă pentru întreaga aplicație. Iconița va fi setată în fișierul manisfest, iar

imaginea ei se va găsi în app/res/mipmap. Ea va fi setată prin eticheta

android:icon=”@mipmap/ic_launcher”.

16

https://developer.android.com/reference/android/app/Activity.html

29

17

Figura 11. Iconița aplicației

4.2. Meniul principal

Meniul principal va fi folosit pentru interacțiunea cu utilizatorul. Acesta

conține următoarele butoane: Joacă, Cadou, Ajutor, Statistici, Ieșire. Fiecare dintre

aceste butoane duce către o activitate nouă cu excepția butonului Ieșire care ne va

scoate din aplicație. Aceste activități trebuie să se regăsesc în fișierul

ManifestAndroid.xml. Imaginea este realizată de mine cu excepția imaginii de la

figura 11. Meniul principal arată astfel:

Figura 12. Meniul principal

17

https://www.topslotsite.com/live-blackjack-online-casino/

30

4.3. Activitatea Blackjack

Activatatea Blackjack este locul în care se va desfășura jocul. După apăsarea

butonului Joacă, utilizator va fi trimis către o interfață unde va putea să-și aleagă

miza pe care dorește să o parieze pentru următorul joc.

Figura 13. Setarea miză

În această interfață avem butoanele -, +, pariază și un text care ne arată suma

pe care am selectat-o. Miza selectată trebuie să fie mai mare ca 0 și să nu

depășească numărul de fise pe care le are jucătorul în momentul respectiv.

public void increaseBet(View view)

if(miza <= player.fise)

miza = miza + 25;

afisareBet(miza);

public void decreaseBet(View view)

if(miza > 0)

miza = miza - 25;

afisareBet(miza);

31

public void afisareBet(int bet)

TextView displayInteger = (TextView) findViewById(R.id.bet);

displayInteger.setText("" + bet);

La momentul apăsării butonului Pariază se pot întâmpla două evenimente

astfel:

În cazul în care suma pariată este 0 jucătorul va primi un mesaj

despre acest lucru și trebuie să modifice miza.

if(miza <= 0)

Context context = getApplicationContext();

CharSequence text = "Miza nu poate fi 0.";

Toast toast = Toast.makeText(context, text, (int) Toast.LENGTH_SHORT);

toast.show();

În cazul în care suma pariată este mai mare ca 0, jucătorul va putea

să intre în joc. El va putea vedea cărțile de joc din mâna sa,

respectiv cartea cu fața în sus a dealerului. Jucătorul va mai putea

vedea și operațiile posibile pe care le va putea face. Pe ecran pe

lângă informațiile despre cărți vor apărea și butoanele pentru

mișcările pe care le poate face jucătorul.

Figura 14. Blackjack primele 2 cărți

32

În figura 14 se poate vedea că operațiile pe care le poate face jucătorul sunt

Hit, Stand, Double, Surrender. Jucătorul nu poate face Split deoarece cărțile pe

care le are el nu au valori egale. Cartea șapte de frunză are valoare 7, iar asul de

frunză are valoarea 11 în cazul de față.

În funcție de operațiile pe care le face jucătorul anumite butoane vor fi

dezactivate. De exemplu dacă jucătorul dorește să se oprească în Figura 14 atunci

el va apăsa butonul Stand și va aștepta ca dealerul să-și facă mutările. Aplicația va

arăta astfel:

Figura 15. Afișarea cărților dealerului

Dacă jucătorul va apăsa Hit prima oară atunci butoanele Double, Surrender,

Split se vor dezactiva deoarece aceste operații sunt valabile atunci când jucătorul

are doar două cărți în mână.

Asul fiind o carte specială poate lua mai multe valori. El va luat valoare 11

dacă suma cărților din mână nu depășește 21, astfel va lua valoare 1.

33

Figura 16. Activare/dezactivare butoane și afișarea asului

După terminarea unei runde de joc sunt plătite către jucător fisele dacă este

cazul și se începe un nou joc apelând comanda recreate(). Recreate() va creat o

nouă activitate, iar activitatea curentă se va distruge.

4.4. Activitatea cadou

În activitatea cadou jucătorul la un anumit interval de timp va primi un

anumite număr de fise, după noroc fiecăruia. Jucătorul va primi între 25 și 1000 de

fise. După apăsarea butonului cadou acest buton devine inactiv timp de o oră.

final Button gift = (Button) findViewById(R.id.idGift);

gift.setOnClickListener(new View.OnClickListener()

public void onClick(View view)

Intent giftIntent = new Intent(view.getContext(), GiftActivity.class);

giftIntent.putExtra("Jucator", player);

startActivityForResult(giftIntent, 0);

gift.setEnabled(false);

new CountDownTimer(600000, 1000)

public void onTick(long x)

//asteapta

34

public void onFinish()

gift.setEnabled(true);

.start(););

18

Figura 17. Primire cadou

După apăsarea butonului cadou pe ecran va apărea un buton care are setat

imaginea de fundal un cadou. După apăsarea cadoului el se va deschide și

imaginea de fundal a activității se va schimba, iar pe ecran va apărea un mesaj cu

numărul de fise câștigate.

public void receiveGift (View view)

Button gift = (Button) findViewById(R.id.idGiftButton);

gift.setVisibility(View.INVISIBLE);

int maxim = 1000, minim = 25;

Random r = new Random();

int premiu = r.nextInt(maxim - minim) + minim;

premiu = premiu - (premiu % 25);

player.adauga(premiu);

18

https://www.shutterstock.com/video/clip-4154698-stock-footage-poker-chips-falling.html

35

TextView d = (TextView) findViewById(R.id.textViewGift);

d.setText("Ai castigat: " + premiu);

player.adauga(premiu);

RelativeLayout linearLayout = (RelativeLayout) findViewById(R.id.idRelativeLayout);

linearLayout.setBackgroundResource(R.drawable.giftwin);

Context context = getApplicationContext();

CharSequence text = "Felicitari!";

Toast toast = Toast.makeText(context, text, (int) Toast.LENGTH_SHORT);

toast.show();

4.5. Activitatea ajutor

Activitatea ajutor oferă detalii despre joc, regulile acestuia și plata

câștigurilor.

Figura 18. Ajutor joc

4.6. Activitatea statistici

Activitatea statistici oferă informații despre istoricul jocurilor de Blackjack,

numărul de fise din prezent și istoricul fiselor. Aceste informații sunt stocate în

36

obiectul din clasa Jucător care este creat la început aplicației. El va prelua

informațiile din baza de date SQLite sau dacă se va deschide pentru prima dată

aceste date vor fi 0 cu excepția numărului de fise care va fi 1000. Interfață este

prezentată în figura 19.

Figura 19. Statistici

4.7. Butonul ieșire

Button iesire = (Button) findViewById(R.id.idIesire);

iesire.setOnClickListener(new View.OnClickListener()

public void onClick(View view)

finish();

System.exit(0);

);

37

5. Strategii pentru câștig

În acest capitol voi prezenta câteva strategii pentru creșterea șanselor de câștig

pentru jucători.

Dacă după împărțirea primelor două cărți avem un scor de sub 11 în mână,

atunci este de preferat să extragem încă o carte deoarece nu putem depăși 21. Vom

proceda la fel și în cazul în care vom avem în mână un as și scorul cărților este de

sub 16.

Cea mai simplă strategie ar fi să tragem cărți din pachetul până ajungem la un

scor de cel puțin 17, dar nu întotdeauna este o strategie câștigătoare.

Dacă cărțile din mână au o valoare între 12 și 16, iar cartea dealerului cu fața în

sus este 7 sau mai mare atunci vom mai trage o carte, altfel ne oprim.

Dacă cărțile din mână au scorul de 10 sau 11, atunci e de preferat să folosim

mai extragem o carte și să dublăm miza. În cazul în care cartea dealerului întoarsă

cu fața în sus este as sau o carte cu valoarea 10 nu vom mai face acest lucru.

Dacă în mână avem perechi de cărți atunci vom proceda astfel:

Perechile 4, 5, 6, 7, 8 sau 9 și cartea dealerului la vedere este mai mică

decât 6 atunci vom împărții cărțile;

Perechile cărților cu valoarea 10 se vor împărții mereu cu excepția în care

dealerul are cartea cu fața în sus un as sau o carte cu valoarea 10;

Dacă cartea dealerul întoarsă cu fața în sus are valoare 10 atunci nu vom

împărții cărțile niciodată.

În cazul în care dealerul are cartea întoarsă un as atunci vom putea plătii

Insurance. Acest pariu nu este profitabil deoarece sunt șanse de doar o treime ca

următoarea carte să aibă valoare 10.

Vom folosi Surrender doar în cazul în care scorul cărților din mână este 16, iar

prima întoarsă a dealerului este as sau o carte cu valoare 10.19

19

http://www.bigmcasino.com/download/870/How to Play BlackJack, 21 Winning Tips MB.pdf

38

6. Concluzii

Aplicația Blackjack, descrisă în această lucrare, este un joc de noroc bazat pe

cărți în care pasionații de acest joc pot încerca să vadă dacă este profitabil sau nu

acest joc pe termen lung. Jucătorii pot încerca diferite strategii pentru aș spori

șansele de câștig fără a fi nevoit să piardă bani reali.

Avantajele acestei aplicații sunt: ușor de înțeles și ușor de folosit, interfața

grafică fiind foarte sugestivă.

Implementarea aplicației nu a ridicat probleme mari pe partea de construcție a

pachetului de cărți, salvarea istoricului jocului sau jocul în sine. Pe de altă parte am

avut dificultăți la partea cu interfețe care se ocupă cu afișarea cărților pe măsură ce

jucătorul mai primește câte o carte.

Consider că am reușit cu succes să implementez această aplicație, să fie

eficientă și ușor de înțeles.

39

7. Direcții de dezvoltare

Pe viitor aplicația poate fi îmbunătățită prin crearea unui server care să permită

jucarea jocului de către mai mulți utilizatori în timp real.Serverul ar crea mese de

Blackjack cu un anumit număr de jucători posibili la acea masă, dar se vor putea

crea și mese private de către utilizatori. Toți cei de la o masă vor juca împotriva

dealerului mesei respective. Fiecare jucător este independent de ceilalți. Regulile

jocului ar rămâne același.

Alte posibile îmbunătățiri ar fi:

Trimiterea mesajelor între jucători;

Conectarea la joc folosind contul de Google sau Facebook;

Aplicația să fie disponibilă pe platforma iOS;

Vizualizarea statisticilor altui jucător;

Crearea de evenimente pe o anumită perioadă de timp. Un exemplu de

eveniment ar fi: cine obține cele mai multe fise într-o săptămână, iar

jucătorii care se vor afla în primii 10% vor primii premii în fise;

Aplicația să fie disponibilă în mai multe limbi;

Jocul să folosească mai multe pachete de cărți pentru șanse mai mari de

câștig.

40

8. Bibliografie

[1] Imaginile cărților au fost preluate de pe:

http://byronknoll.blogspot.ro/2011/03/vector-playing-cards.html

[2] „How to play Blackjack 21 Winnings Tips” este un carte furnizată de The

Big “M” Casino, Myrtle Beach. Prealuată de pe:

http://www.bigmcasino.com/download/870/How to Play BlackJack, 21

Winning Tips MB.pdf

[3] PROFESSIONAL ANDROID™ 4 APPLICATION DEVELOPMENT de

Reto Meier. Preluată de pe:

http://yuliana.lecturer.pens.ac.id/Android/Buku/professional_android_4_app

lication_development.pdf

[4] Google Inc. „Android Developers” https://developer.android.com/index.html

[5] Jocul Blackjack https://en.wikipedia.org/wiki/Blackjack

a. https://www.pokerstarscasino.ro/games/blackjack/

[6] „Curs practic de Java", Cristian Frăsinaru de pe:

http://profs.info.uaic.ro/~acf/java/Cristian_Frasinaru-

Curs_practic_de_Java.pdf

[7] SQLite https://ro.wikipedia.org/wiki/SQLite