Blackjack Aplicație Android - profs.info.uaic.roalaiba/pub/absolvire/2017 iarna/Blackjack -...
Transcript of Blackjack Aplicație Android - profs.info.uaic.roalaiba/pub/absolvire/2017 iarna/Blackjack -...
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