Referat de laborator nr.

Tema:

1. Folosirea lui prompt, confirm, alert

Crearea unui joc de tip Spânzurătoarea

Cu toții știm jocul Spânzurătoarea: un jucător alege un cuvânt, iar altul

încearcă să-l ghicească. De fiecare dată când acesta din urmă ghicește o
literă care se găsește în cuvântul ascuns, primul jucător este obligat să
arate litera și locul acesteia în cuvânt. Dacă litera nu face parte din cuvânt
se pierde un punct și primul jucător desenează păți dintr-un om pentru
fiecare răspuns greșit.

Programul JavaScript va alege cuvântul iar noi vom ghici literele.

Pentru a crea acest joc, vom folosi prompt, alert și confirm pentru a
putea introduce literele, a anunța jucătorul un mesaj, sau a aștepta ca
acesta să apese OK sau CANCEL.

Înainte de a începe să scriem codul pentru joc, să ne gândim la

structura acestuia. Există câteva cerințe pe care programul trebuie să le
respecte:

1. Alegem un cuvânt oarecare.

2. Cerem litera jucătorului.
3. Terminăm jocul dacă un jucător dorește acest lucru.
 4. Verificăm dacă litera jucătorului este o literă validă.
5. Arătăm locul acesteia în cuvânt.
6. Arătăm progresul făcut de jucător.
7. Terminăm atunci când jucătorul a ghicit cuvântul.

În afară de primul și ultimul pas, ceilalți 5 pași se vor întâmpla de mai

multe ori, nu știm de câte ori (depinde de cât de bine este ghicit cuvântul
secret).

Dacă nu v-ați făcut încă o idee, citiți descrierea jocului în pseudocod:

Alegem un cuvânt aleatoriu

Atâta timp cât (while) cuvântul nu a fost ghicit

{

Arătăm jucătorului progresul acestuia

Obținem o literă de la jucător

Dacă (if) jucătorul dorește să termine jocul

{

Jocul se încheie

}Altfel, dacă (else if) a introdus mai mult de

o literă {

Cerem jucătorului să aleagă o singură

literă
 }Altfel (else) {

Dacă litera face parte din cuvânt {

Se afișează progresul jucătorului cu

litera găsită

Se felicită jucătorul pentru ghicirea cuvântului.

Pentru jocul nostru, a arăta jucătorului progresul acestuia, înseamnă a-i

arăta literele ghicite corect și spațiile albe (adică literele lipsă) din cuvânt.
Vom face acest lucru, folosind un vector, numit vector_răspuns, un
vector de spații goale, pentru fiecare literă din cuvânt, reprezentată prin
șirul “_”.

De exemplu, dacă cuvântul secret este cascada, vectorul va arăta:

Dacă jucătorul ghicește corect litera c, vectorul va arăta:

Odată ce jucătorul a ghicit toate literele , vectorul completat va fi:

Vom folosi și o variabilă care va calcula câte litere mai are de ghicit
jucătorul. Pentru fiecare apariție a unui răspuns corect, această variabilă
va fi decrementată cu 1. Atunci când va ajunge la 0 vom ști că jucătorul
a câștigat.

Jocul poate fi rulat într-o buclă while, în care se afișează starea curentă
a cuvântului care trebuie ghicit (începând cu spații albe în număr egal cu
numărul literelor din cuvânt), cerem jucătorului o literă (și ne asigurăm
că este validă, adică avem o singură literă introdusă) și updatăm
vectorul_răspuns cu litera aleasă anterior, dacă aceasta apare în
cuvânt. Odată ce jucătorul a ghicit toate literele din cuvânt, îi vom arăta
cuvântul completat și un mesaj de felicitare.

a) Alegerea unui cuvânt

Prima dată trebuie să alegem un cuvânt oarecare.

De exemplu, vom începe jocul creând un vector de cuvinte (piersica,

maimuta, clatita, cascada) ce vor fi folosite ca și sursă pentru cuvântul
secret, și salvăm vectorul în variabila cuvinte. Cuvintele ar trebui să fie
toate scrise cu literă mică. Apoi, folosind Math.random și
Math.floor alegem un cuvânt oarecare din vector:
 b) Crearea vectorului răspuns

În continuare, pornim cu un vector gol, numit vector_raspuns, pe

care îl umplem cu (_) pentru a se potrivi cu numărul de litere din cuvântul
secret:

Bucla for creează o variabilă i ce pornește de la 0 până la lungimea

cuvântului. De fiecare dată, se adaugă un nou element în vectorul
vector_raspuns, apoi la finalul buclei, acesta va avea aceeași
lungime cu variabila cuvant. De exemplu, dacă cuvântul secret este
cascada (care are 7 litere) vectorul va avea 7 (_):

Variabila litere_ramase este folosită pentru a ști câte litere mai sunt
de ghicit. De fiecare dată când jucătorul ghicește o literă, valoarea
acesteia se va decrementa, pentru fiecare instanță a acelei litere în
cuvânt.

c) Bucla while a jocului

Folosim o buclă while cu condiția litere_ramase > 0 să fie TRUE.
În corpul acestei bucle, va trebui calculată variabila litere_ramase
pentru fiecare literă corect găsită de jucător. De îndată ce se ghicesc
toate literele, litere_ramase va fi 0 și bucla se încheie.

Primul lucru care trebuie realizat în interiorul buclei while a jocului este
să-i arătăm jucătorului progresul. Acest lucru se va realiza cu un simplu
alert:

Acest alert arată jucătorului șirul obținut prin unirea tuturor

elementelor din variabila vector_raspuns.

De exemplu, dacă cuvântul secret este cascada, iar jucătorul a ghicit

până acum litera c și litera a, atunci vectorul vector_raspuns ar
arăta:

iar vector_raspuns.join(“ ”) ar fi “c a _ c a _ a”, iar fereastra

de dialog:
În continuare alegerea literei de la jucător și asigurarea că aceasta este
un singur caracter:

Prompt-ul preia litera ghicită de jucător și o salvează în variabila

litera. În continuare pot exista 4 posibilități:

- Dacă jucătorul apasă CANCEL atunci litera va fi null. Se verifică

această condiție cu if și dacă condiția este TRUE, folosim break
pentru a ieși din buclă. Folosim break în orice buclă pentru
ieșirea imediată din ea, indiferent dacă condiția while este sau
nu TRUE.
- A doua și a treia posibilitate este dacă jucătorul nu introduce nici o
literă sau introduce prea multe litere. Dacă nu introduce nimic și
 apasă OK, variabila litera va fi un șir gol. În acest caz,
litera.length va fi 0. Dacă se introduce mai mult de o literă,
litera.length va fi mai mare ca 1. Astfel, în else if
(litera.length !==1) verificăm aceste condiții și ne
asigurăm că litera este exact o literă. Dacă nu, afișăm un mesaj
în care cerem jucătorului să introducă doar o singură literă.
- A patra posibilitate este aceea în care jucătorul introduce o literă
validă pentru cuvântul secret. În continuare, va trebui updatată
starea jocului cu ghicirea literei, folosind else.

Update-ul se realizează de fiecare dată când jucătorul a introdus o literă

validă, adică va trebui updatat vectorul vector_raspuns în
concordanță cu litera ghicită. Astfel, în ultimul else vom avea:

Am creat o nouă buclă for cu o nouă variabilă j ce pornește de la 0 și

ajunge până la cuvant.length. Folosim această buclă pentru a
parcurge fiecare literă a cuvântului secret. De exemplu, dacă cuvântul
este “cascada”, prima dată, când j=0, cuvant[j]=”c”, apoi data
viitoare, cuvant[j]=”a”, apoi, “s”, “c”, ”a”, “d” și în final
“a”.

Condiția if (cuvant[j] === litera) este folosită pentru a

verifica dacă litera curentă se potrivește cu litera introdusă de jucător.
Dacă da, folosim vector_raspuns[j] = litera pentru a updata
vectorul răspuns cu ghicirea curentă. Pentru fiecare literă din cuvânt care
se potrivește cu litera introdusă de jucător, se realizează update-ul
vectorului vector_raspuns în locul corespunzător. Acest lucru este
posibil deoarece variabila j poate fi folosită ca și index pentru
vector_raspuns și la fel de bine poate fi folosită ca index pentru
variabila cuvant.

De exemplu, să ne imaginăm că tocmai am început să jucăm jocul și am

ajuns la for-ul de mai sus. Să presupunem că cuvântul pe care trebuie
să-l ghicim este “cascada”, litera este “a”, iar vectorul
vector_raspuns arată ca acesta:

Prima dată în for, j = 0, deci cuvant[j]=”c”. Litera ghicită

este “a”, deci se va sări peste if deoarece “c” === “a” este FALSE.

A doua oară, j = 1, deci cuvant[j]=”a”. Aceasta este egal cu litera,

deci se va parcurge if-ul. Linia vector_raspuns[j] = litera;
setează elementul la indexul 1 (al doilea element) al vectorului, deci
acum acesta va arăta:

Următoarele două ori, cuvant[j]=”s” și apoi cuvant[j]=”c”,

ceea ce înseamnă că nu se potrivește cu litera.

Atunci când j = 4, cuvant[j]=”a” este updatat din nou vectorul, de

data aceasta setarea se face la elementul de la indexul 4 (al cincilea
element) pentru variabila litera. Acum, vectorul arată:

În continuarea buclei, când j = 5 , litera nu se potrivește, dar atunci când

se ajunge la finalul buclei, adică j = 6, cuvant[j]=”a” și vectorul este
updatat, de data aceasta setarea se face la elementul de la indexul 6 (al
șaptelea element) pentru variabila litera. În finalul parcurgerii acestei
bucle, vectorul va conține toate aparițiile literei ghicite:

Pentru fiecare ghicire corectă a unei litere din cuvântul căutat, variabila
litere_ramase va fi decrementată cu 1. Atunci când jucătorul a
ghicit toate literele , această variabilă va fi 0.

d) Terminarea jocului
Așa cum am văzut, condiția din bucla while este litere_ramase
>0 , deci atâta timp cât mai sunt litere de ghicit, bucla va continua. Atunci
când litere_ramase ajunge la 0, ieșim din buclă, iar jocul se poate
termina cu un mesaj de forma:

Prima linie folosește alert pentru a arăta răspunsul pentru ultima dată.
A doua linie folosește alert pentru a felicita jucătorul.

Ex1: Creați un fișier, numit Spanzuratoarea.html, care să conțină jocul

SPANZURATOAREA. Puteți folosi codul prezentat sau realizați o versiune
proprie.

Ex2: Adăugați propriile cuvinte la vectorul cuvinte. Amintiți-vă să le

introduceți cu literă mică. Dacă jucătorul va introduce o majusculă,
atunci aceasta nu se va potrivi cu literele din cuvântul secret. Pentru a
rezolva această potențială problemă, convertiți litera introdusă de
jucător în literă mică. Puteți folosi metoda toLowercase() pentru
conversia respectivă.

Ex3: Jocul propus oferă jucătorului un număr nelimitat de încercări.

Adăugați o variabilă care să țină numărul de încercări făcute de jucător și
terminați jocul dacă acesta rămâne fără încercări!