Acasă › Instalare și configurare › Crearea unui joc tic-tac-toe. Bazele teoretice ale dezvoltării

Crearea unui joc tic-tac-toe. Bazele teoretice ale dezvoltării

Salutări, dragi prieteni! În această lecție vă voi arăta cum puteți crea un joc de browser - tic-tac-toe, în javascript! Știți cu toții ce este acest joc și cum să-l jucați, dar permiteți-mi să vă reamintesc din nou:

Tic-tac-toe este un joc logic între doi jucători pe un câmp pătrat de 3 pe 3 celule (posibil mai mare). Unul se joacă cu „cruci”, iar al doilea cu „degetele de la picioare”.

P.S. ca și în toate lecțiile similare de javascript, la sfârșitul articolului puteți descărca fișierul sursă și, de asemenea, puteți vedea rezultatul lucrării într-un exemplu demonstrativ!

Descrierea jocului care se creează

Să ne uităm la caracteristicile jocului:

jocul începe imediat după încărcarea paginii;
dreptul de a merge primul se alege aleatoriu (fie te apuci de mers pe jos, fie la calculator);
semnul pe care vei paria este ales aleatoriu (o cruce sau un zero);
dacă jucătorul câștigă, simbolurile câștigătoare (o fâșie de cruci sau zerouri) sunt evidențiate cu verde;
dacă jucătorul pierde în fața computerului, bara este evidențiată în roșu;
Deasupra câmpului există o linie de informații în care este afișat rezultatul (victorie sau înfrângere).

Logici

Nu am venit cu algoritmi complexi (universali) pentru un teren de joc de 3 pe 3 pătrați, am mers în sens invers - forța brută! (mai multe despre asta puțin mai târziu). Am identificat trei etape secvențiale principale pe care se sprijină toată logica:

Etapa 1: verifică dacă jucătorul a câștigat?

În această etapă, verificăm dacă există 3 celule (pe aceeași linie) umplute cu aceleași simboluri de jucător (cruci sau zerouri). Acestea. indiferent care este mișcarea (chiar și prima), întotdeauna verificăm mai întâi dacă jucătorul a câștigat. Iată cum arată victoria:

Etapa 2: verificare - poate computerul să câștige cu următoarea mișcare?

În această etapă, căutăm o linie în care ar fi 2 celule umplute de computer și o celulă goală - adică încercăm să câștigăm din cauza neatenției jucătorului. Iată cum arată înfrângerea (adică o victorie pe computer):

Etapa 3: nu te lăsăm să câștigi!

Aici căutăm aceeași linie ca în a doua etapă, doar 2 celule trebuie să fie umplute cu semnele de joc ale jucătorului, adică în această etapă nu permitem computerului să piardă prin plasarea unui semn într-o celulă goală. Fiecare dintre etape reprezintă o funcție independentă - puteți vedea acest lucru în codul js de mai jos.

Implementarea

Dispunerea terenului de joc este foarte simplă - blocul principal conține o linie de informații (clasă - rezultat) și 9 blocuri, care sunt celule (clasă - bloc) Dispunerea HTML a celulelor:

Randul tau!

Celula de clasă auxiliară este necesară pentru a identifica cu exactitate celula dorită pe terenul de joc. Stiluri CSS pentru terenul de joc:

Krestiki_noliki( lățime: 306px; margine: 0 auto; ) .krestiki_noliki .block( lățime: 100px; înălțime: 100px; chenar: 1px solid #ccc; cursor: pointer; float: stânga; text-align: center; font-size: 100px; înălțimea liniei: 94px; )

Acum să ne uităm la întregul cod JS, după care voi vorbi despre punctele principale:

$(document).ready(function())( var znak_user = "O"; var znak_comp = "X"; var rand_num = Math.round((Math.random() * (9 - 1) + 1)); if (rand_num > 3)( var znak_comp = "O"; var znak_user = "X"; $(".cell"+rand_num).text(znak_comp); ) var exit_flag = false; var win_user_array = ["123", " 456","789","147","258","369","159","357"]; //Determină funcția de victorie a jucătorului check_3_user(znak)( pentru (var i = 0; i< 8; i++) { var first = "cell" + win_user_array[i].substr(0,1); var second = "cell" + win_user_array[i].substr(1,1); var third = "cell" + win_user_array[i].substr(2,1); if($("."+first).text() == znak && $("."+second).text() == znak && $("."+third).text() == znak){ $("."+first+",."+second+",."+third).css("background-color", "#83e2c3"); $(".result").text("Вы выиграли!"); $(".krestiki_noliki .block").unbind("click"); exit_flag = true; } } } //Определяем возможность победы компьютера function check_2_comp(znak){ for (var i = 0; i < 8; i++) { var first = "cell" + win_user_array[i].substr(0,1); var second = "cell" + win_user_array[i].substr(1,1); var third = "cell" + win_user_array[i].substr(2,1); if($("."+first).text() == znak && $("."+second).text() == znak && $("."+third).text() == "" && exit_flag == false){ $("."+third).text(znak); $("."+first+",."+second+",."+third).css("background-color", "#EF7C7C"); $(".result").text("Вы проиграли!"); $(".krestiki_noliki .block").unbind("click"); exit_flag = true; } if($("."+first).text() == znak && $("."+second).text() == "" && $("."+third).text() == znak && exit_flag == false){ $("."+second).text(znak); $("."+first+",."+second+",."+third).css("background-color", "#EF7C7C"); $(".result").text("Вы проиграли!"); $(".krestiki_noliki .block").unbind("click"); exit_flag = true; } if($("."+first).text() == "" && $("."+second).text() == znak && $("."+third).text() == znak && exit_flag == false){ $("."+first).text(znak); $("."+first+",."+second+",."+third).css("background-color", "#EF7C7C"); $(".result").text("Вы проиграли!"); $(".krestiki_noliki .block").unbind("click"); exit_flag = true; } } } //Определяем ход компьютера function check_2_user(znak){ for (var i = 0; i < 8; i++) { var first = "cell" + win_user_array[i].substr(0,1); var second = "cell" + win_user_array[i].substr(1,1); var third = "cell" + win_user_array[i].substr(2,1); if(exit_flag == false){ if($("."+first).text() == znak && $("."+second).text() == znak && $("."+third).text() == ""){ $("."+third).text(znak_comp); exit_flag = true; } } if(exit_flag == false){ if($("."+first).text() == znak && $("."+second).text() == "" && $("."+third).text() == znak){ $("."+second).text(znak_comp); exit_flag = true; } } if($("."+first).text() == "" && $("."+second).text() == znak && $("."+third).text() == znak){ $("."+first).text(znak_comp); exit_flag = true; } if(exit_flag) break; } } $(".krestiki_noliki .block").click(function(){ //Если клетка пустая if($(this).text() == ""){ $(this).text(znak_user); check_3_user(znak_user); check_2_comp(znak_comp); check_2_user(znak_user); if(exit_flag == false){ for (var i = 1; i < 10; i++) { if($(".cell"+i).text() == ""){ $(".cell"+i).text(znak_comp); break; } } }else exit_flag = false; } }); });

Mai întâi, declarăm variabilele: znak_user - în această variabilă stocăm semnul cu care utilizatorul se va juca (în mod implicit, acolo este stocat un zero - aceasta este caseta engleză „O”). znak_comp - în această variabilă stocăm semnul cu care se va juca computerul (în mod implicit, acolo este stocată o cruce - aceasta este caseta engleză „X”).

Logica este aceasta: dacă numărul aleatoriu este mai mare de 3, atunci computerul joacă cu zerouri, iar el (calculatorul) face prima mișcare.

Puteți schimba această logică la fel de convenabil pentru dvs., de exemplu, puteți crea mai multe numere aleatorii pentru a face mai multe opțiuni pentru cine va fi primul și ce semne. exit_flag - acest steag (variabilă) este responsabil pentru ieșirea din funcție, adică, de exemplu, atunci când computerul și-a făcut deja mișcarea și trebuie să ieșiți din funcție și să transmiteți mutarea jucătorului. win_user_array - această matrice stochează toate opțiunile câștigătoare pentru umplerea celulelor. Pentru a fi clar, să aruncăm o privire la această imagine:

Fiecare element al matricei este un șir de trei numere, care este o combinație câștigătoare, adică, de exemplu, dacă completați celulele de sub numerele 1, 2 și 3, atunci victoria (sau înfrângerea) va avea loc. După cum puteți vedea, există 8 opțiuni câștigătoare în total; sarcina noastră este să trecem prin toate aceste opțiuni. Urmează 3 funcții:

verifica_3_utilizator();
check_2_comp();
verifica_2_utilizator();

Scopul acestor funcții este descris (în trei pași) în secțiunea Logic (mai sus). Aceste funcții sunt apelate făcând clic pe oricare dintre celulele din câmp. Un parametru (znak) este transmis fiecăreia dintre funcții - acesta este semnul jucătorului sau al computerului (o cruce sau un zero), de exemplu, la funcția care determină victoria jucătorului (check_3_user), trecem semnul jucătorului în ordine pentru a găsi 3 semne identice pe aceeași linie.

După trei funcții (dacă computerul nu a făcut încă o mișcare), computerul umple una dintre celulele libere. Aici, puteți complica jocul, de exemplu, făcând astfel încât, dacă celula centrală este liberă (celula numărul 5), atunci mai întâi mizați în ea; dacă este ocupată, atunci mizați într-unul dintre colțurile libere (acestea sunt celulele nr. 1, 3, 7 și 9) și așa mai departe - în general, aici este la discreția dvs.

Asta, în principiu, este tot ceea ce este necesar pentru a crea un astfel de joc.

Acum puteți viziona jocul folosind un exemplu demonstrativ și puteți descărca fișierul sursă (1 fișier în total).

06/08/2018 - mulțumesc pentru atenția acordată autorului scrisorii: Patvakan Baghdasaryan, o eroare a fost remediată când computerul avea mai multe opțiuni posibile victoriile și toate mișcările sale câștigătoare au fost pictate (de la 4 la 6 celule, în loc de 3).

Asta e tot pentru mine, sper ca aceasta lectie ti-a fost de folos, iti doresc mult succes, pa!

Cum să scrii un bot care nu poate fi învins la tic-tac-toe sau Introducere în regula minimax

Este foarte posibil ca, după sute de jocuri de tic-tac-toe, să te fi întrebat: care este algoritmul optim? Dar dacă sunteți aici, atunci probabil că ați încercat și să scrieți o implementare a acestui joc. Vom merge mai departe și vom scrie un bot care va fi imposibil de învins la tic-tac-toe. Anticipând întrebarea ta „de ce?”, vom răspunde: datorită algoritmului.

La fel ca un jucător profesionist de șah, acest algoritm calculează acțiunile adversarului cu câteva mișcări înainte - până când ajunge la sfârșitul jocului, fie că este o victorie, o înfrângere sau o remiză. Odată ajuns în această stare finală, AI își va acorda un număr pozitiv de puncte (în cazul nostru +10) pentru o victorie, negativ (-10) pentru o înfrângere și neutru (0) pentru o remiză.

În același timp, algoritmul efectuează calcule similare pentru mișcările jucătorului. Va alege mutarea cu cel mai mare scor dacă AI se mișcă și mutarea cu cel mai mic scor dacă jucătorul se mișcă. Folosind această strategie, minimax evită înfrângerea.

Încercați să jucați acest joc.

Algoritmul minimax este cel mai ușor descris ca o funcție recursivă care:

returnează o valoare dacă este găsită starea finală (+10, 0, -10),
trece prin toate celulele goale de pe teren,
apelează funcția minimax pentru fiecare dintre ele (recursie),
evaluează valorile obţinute
și returnează cel mai bun.

Dacă nu sunteți familiarizat cu recursiunea, atunci ar trebui să urmăriți această prelegere de la cursul Harvard CS50:

Pentru a înțelege cum funcționează minimax, să-i scriem implementarea și să-i modelăm comportamentul. Ne vom ocupa de asta în următoarele două secțiuni.

Implementare Minimax

Ne vom uita la o situație în care jocul se apropie de sfârșit (vezi imaginea de mai jos). Deoarece minimax trece prin toate stările posibile ale jocului (și există sute de mii de ele), este logic să luăm în considerare finalul jocului - în acest fel va trebui să urmărim un număr mai mic de apeluri de funcții recursive (9 în total).

Lasă AI să se joace cu cruci, persoana - cu zerouri.

Pentru a face lucrul cu câmpul mai ușor, să-l declarăm ca o matrice de 9 elemente cu valori egale cu conținutul celulelor. Să-l umplem cu cruci și degete de la picioare, ca în imaginea de mai sus și să-i spunem origBoard.

Var origBoard = ["O",1,"X","X",4,"X",6,"O","O"];

În continuare, vom declara variabilele aiPlayer și huPlayer și le vom atribui valorile „X” și respectiv „O”.

În plus, vom avea nevoie de o funcție care caută combinații câștigătoare și returnează o valoare adevărată dacă căutarea are succes și de o funcție care stochează indicii celulelor disponibile.

/* stare initiala scânduri O | | X --------- X | | X --------- | O | O */ var origBoard = [“O”,1 ,”X”,”X”,4 ,”X”, 6 ,”O”,”O”]; // person var huPlayer = „O”; // AI var aiPlayer = „X”; // returnează o listă de indici ai celulelor goale din funcția emptyIndices(board)( return board.filter(s => s != "O" && s != "X"); ) // combinații câștigătoare ținând cont funcția de indici câștigătoare(board, player)( if((board == player && board == player && board == player) || (board == player && board == player && board == player) || (board == player && board == player && board == player) || = player && board == player && board == player) || (board == player && board == player && board == player) || (board == player && board == player && board == player) | | (board == player && board == player && board == player) || (board == player && board == player && board == player) || (board == player && board == player && board == = jucător)) ( returnează adevărat; ) else ( returnează fals; ) )

Deci, să definim o funcție minimax cu două argumente: newBoard și player. Apoi vom găsi indicii celulelor libere pe teren și îi vom trece variabilei availSpots.

// funcția principală minimax minimax(newBoard, player)( // celule disponibile var availSpots = emptyIndices(newBoard);

În plus, trebuie să urmărim stările finale și să returnăm valorile corespunzătoare. Dacă „zero” câștigă, trebuie să returnați -10, dacă „cruce” - +10. Dacă dimensiunea matricei availSpots este zero, atunci nu există celule libere, jocul se va încheia la egalitate și zero trebuie returnat.

// verifică starea terminalului (câștig/pierdere/remiză) //și returnează o valoare în consecință if (winning(newBoard, huPlayer))( return (scor:-10); ) else if (winning(newBoard, aiPlayer)) ( return (scor:10); ) else if (availSpots.length === 0)( return (score:0); )

După aceasta, trebuie să aduni puncte din fiecare dintre celulele goale. Pentru a face acest lucru, vom crea o serie de mișcări și vom parcurge toate celulele goale într-o buclă, plasând indicii și punctele fiecărei mișcări în obiectul de mișcare.

Apoi setăm indexul celulei goale, care a fost stocat ca număr în origBoard, egal cu proprietatea index a obiectului mutare. Apoi vom merge ca jucător curent într-o celulă goală a noului câmp newBoard și vom apela funcția minimax de la celălalt jucător și câmpul rezultat newBoard. După aceasta, trebuie să puneți proprietatea scor a obiectului returnat de funcția minimax în proprietatea scor a obiectului mutare.

Dacă minimax nu găsește o stare terminală, continuă să se miște recursiv mai adânc în joc până când ajunge la o stare terminală. După aceea, transferă punctele acestui „nivel” de recursivitate la un nivel mai înalt.

În cele din urmă, funcția resetează modificările la newBoard și plasează obiectul de mișcare în matricea de mișcări.

// matrice pentru a stoca toate obiectele var moves = ; // parcurge celulele disponibile pentru (var i = 0; i< availSpots.length; i++){ //create an object for each and store the index of that spot var move = {}; move.index = newBoard]; // совершить ход за текущего игрока newBoard] = player; //получить очки, заработанные после вызова минимакса от противника текущего игрока if (player == aiPlayer){ var result = minimax(newBoard, huPlayer); move.score = result.score; } else{ var result = minimax(newBoard, aiPlayer); move.score = result.score; } // очистить клетку newBoard] = move.index; // положить объект в массив moves.push(move); }

Minimax trebuie apoi să selecteze cea mai bună mișcare din matricea de mișcări. Are nevoie de mutarea cu cel mai mare scor dacă AI se mișcă și cu cel mai mic punctaj dacă este o mișcare umană. Astfel, dacă valoarea jucătorului este aiPlayer , algoritmul inițializează variabila bestScore la un număr foarte mic și trece prin matricea de mișcări: dacă un scor de mutare valorează mai mult scor decât bestScore , algoritmul își amintește acea mișcare. În cazul mișcărilor cu puncte egale, algoritmul își amintește prima.

În cazul în care jucătorul este egal cu huPlayer , totul este similar - doar acum bestScore este inițializat la un număr mare, iar minimax caută mutarea cu cele mai puține puncte.

Ca rezultat, minimax returnează obiectul stocat în bestMove .

// dacă aceasta este o mișcare AI, treceți prin mișcări și selectați mutarea cu cele mai multe puncte var bestMove; if(player === aiPlayer)( var bestScore = -10000; for(var i = 0; i< moves.length; i++){ if(moves[i].score >bestScore)( bestScore = moves[i].score; bestMove = i; ) ) )else( // altfel treceți în buclă prin mișcări și selectați mutarea cu cele mai puține puncte var bestScore = 10000; for(var i = 0; i< moves.length; i++){ if(moves[i].score < bestScore){ bestScore = moves[i].score; bestMove = i; } } } // вернуть выбранный ход (объект) из массива ходов return moves; }

În secțiunea următoare, vom simula programul nostru pentru a înțelege cum funcționează.

Minimax în acțiune

Folosind diagrama de mai jos, vom analiza modelul pas cu pas al algoritmului.

Notă: În diagramă, numerele mari indică numărul de serie al apelului de funcție, iar nivelurile indică câte mișcări a făcut algoritmul.

OrigBoard și aiPlayer sunt alimentate la algoritm. Face o listă a celor trei celule goale găsite, verifică caracterul finit al stării și parcurge toate celulele goale. Algoritmul schimbă apoi newBoard , plasând aiPlayer în primul pătrat gol. După aceea, se autoapelează de la newBoard și huPlayer și așteaptă ca al doilea apel să returneze o valoare.
În timp ce primul apel de funcție este încă în rulare, al doilea rulează, creând o listă de două celule goale, verificând starea finită și parcurgând toate celulele goale. Al doilea apel modifică apoi newBoard prin plasarea huPlayer în primul pătrat gol. După aceea, se autoapelează de la newBoard și aiPlayer și așteaptă ca al treilea apel să returneze o valoare.
Deoarece al doilea apel a găsit două celule goale, minimax modifică newBoard plasând huPlayer în a doua celulă goală. Apoi se numește de la newBoard și aiPlayer.
Algoritmul alcătuiește o listă de celule goale și înregistrează victoria jucătorului după verificarea caracterului finit al stării. Deci returnează un obiect cu un câmp de scor de (-10).
În al doilea apel de funcție, algoritmul primește valorile returnate de la nivelul inferior de al treilea și al patrulea apel de funcție. Deoarece mișcarea lui huPlayer a produs aceste două rezultate, algoritmul îl alege pe cel mai mic. Deoarece sunt aceleași, algoritmul îl alege pe primul și îl transmite primului apel de funcție.

În acest moment, primul apel de funcție a primit o estimare a mișcării aiPlayer la prima celulă goală. Apoi modifică newBoard plasând aiPlayer în al doilea pătrat gol. După aceea, se numește de la newBoard și huPlayer.
În al cincilea apel de funcție, algoritmul compilează o listă de celule goale și înregistrează victoria AI după verificarea caracterului finit al stării. Deci returnează un obiect cu un câmp de scor de +10.
După aceasta, primul apel modifică newBoard plasând aiPlayer în a treia celulă goală. Apoi se numește de la newBoard și huPlayer.
Al șaselea apel face o listă cu două celule goale, verifică caracterul finit al stării și parcurge toate celulele goale. Apoi modifică newBoard plasând huPlayer în primul pătrat gol. Apoi se autoapelează de la newBoard și aiPlayer și așteaptă ca al șaptelea apel să returneze o valoare.
Noul apel construiește o listă cu o celulă goală, verifică starea finită și modifică newBoard pentru a plasa aiPlayer în celula goală. După aceea, se autoapelează de la newBoard și huPlayer și așteaptă ca acest apel să returneze o valoare.
A opta provocare este lista goala celulele goale și înregistrează victoria aiPlayer după verificarea stării membrelor. Prin urmare, returnează un obiect cu un câmp de numărare egal cu (+10) la nivelul de mai sus, al șaptelea apel.
Al șaptelea apel a primit o singură valoare pozitivă de la nivelurile inferioare. Deoarece această valoare a fost obținută la rândul lui aiPlayer, algoritmul returnează cea mai mare valoare obținută. Deci returnează o valoare pozitivă (+10) la nivelul de sus, al șaselea apel.

Deoarece al șaselea apel a găsit două celule goale, minimax modifică newBoard plasând huPlayer în a doua celulă goală. Apoi se numește de la newBoard și aiPlayer.
După aceasta, algoritmul alcătuiește o listă de celule goale și înregistrează victoria aiPlayer după verificarea caracterului finit al stării. Prin urmare, returnează un obiect cu un câmp de scor egal cu (+10) la nivelul de mai sus.
În acest moment, a șasea provocare trebuie să aleagă între scorul (+10) pe care l-a întors a șaptea provocare și scorul (-10) pe care l-a returnat a noua provocare. Deoarece mișcarea lui huPlayer a produs aceste două rezultate, algoritmul îl selectează pe cel mai mic și îl întoarce la nivelul următor ca obiect cu câmpuri de scor și index.

În cele din urmă, toate cele trei ramuri ale primului apel sunt evaluate (-10, +10, -10). Deoarece mutarea lui aiPlayer a produs aceste trei rezultate, algoritmul selectează obiectul care conține cel mai mare număr de puncte (+10) și indicele acestuia (4).

În scenariul de mai sus, minimax decide că alegere optimă va avea loc o mutare în careul central al terenului.

Sfârşit!

Până acum ar fi trebuit să înțelegi cum funcționează algoritmul minimax. Încercați să scrieți singur o implementare sau priviți un exemplu pe GitHub sau CodePen și optimizați-l.

Dacă sunteți interesat de subiectul AI în jocuri, vă recomandăm să citiți materialele noastre pe acest subiect.

PASUL 1. CONFIGURAREA PARAMETRILOR FORMULUI1. Pentru a personaliza un formular, setați dimensiunea acestuia
510 de puncte pe orizontală și 480 de puncte pe orizontală
vertical. Maxim și minim
indicați dimensiunea egală cu aceleași valori.
2. Numiți forma „Tic Tac Toe”.
3. Pentru fundalul formularului, utilizați un fișier din folder
Imagini sub numele background.png și plasați-o
în centrul formei.
4. Pentru o pictogramă în linia de titlu
utilizați fișierul de utilizare din folder
Imagini sub numele menu4.ico.
5. Culoarea de fundal a formularului trebuie setată
MintCream.

PASUL 2. ADĂUGAREA UNUI BUTON ȘI ETICHETĂ LA FORMULARE

1. Pentru elementele plasate, schimbați
dimensiunea fontului la 12 și fundalul setat
transparent.

1. Creați o bară de meniu cu elemente
așa cum se arată în imagine.

PASUL 3. ADĂUGAREA O BARĂ DE MENIU LA FORMULARE

1. În elementul de meniu Fișier, creați o comandă
Ieșire.
2. Pentru
echipe
Ieșire
hai sa prescriem
codul programului este același ca în
cererea anterioară.

PASUL 3. ADĂUGAREA O BARĂ DE MENIU LA FORMULARE

1. În elementul de meniu Joc, creați o echipă
Un joc nou.
2. Pentru comanda Joc nou vom scrie
codul programului în viitor prin
câțiva pași.

PASUL 3. ADĂUGAREA O BARĂ DE MENIU LA FORMULARE

1. În elementul de meniu Ajutor, creați o comandă
Despre program.
2. Pentru comanda Despre program, creați una nouă
formează și scrie codul programului
asemănător cu cel precedent
aplicarea.

1. Tragând un obiect PictureBox în formular
schimbați-i dimensiunea la 100x100.
2. Setați un fundal transparent.
3. Așezați PictureBox-ul așa cum se arată în
poza de deasupra primei celule a terenului de joc.

PASUL 4. ADĂUGAREA OBIECTELOR PICTUREBOX LA FORMULAR

1
2
3
4
5
6
7
8
9
1. Deasupra celulelor rămase asezăm
Obiecte PictureBox, copii ale primei
obiect, conform numerotării indicate pe
Imagini.

1. Înainte de a scrie codul
necesare în folder
\Studio vizual
2010\Projects\Tic Tac Toe\X's
zerourile\bin\Debug\ trebuie reluate
fișierele x.png, 0.png, none.png din folderul Imagini.
2. Faceți dublu clic cu mouse-ul stâng pe primul
PictureBox.

PASUL 5. ADĂUGAREA CODULUI PENTRU OBIECTE PICTUREBOX

1. Creați o matrice bidimensională accesibilă tuturor elementelor din
creat sub forma unor elemente 3x3 formate din numere întregi. Pe loc
îl umplem cu zerouri când îl declarăm. Pentru celulele goale noi
Vom folosi 0, pentru „cruci” - 1 și pentru „zerouri” - -1.

PASUL 5. ADĂUGAREA CODULUI PENTRU OBIECTE PICTUREBOX

În procedura când faceți clic pe primul
PictureBox, adăugați un operator
alegere
care
voi
verifica statusul
celule matrice. Dacă valoarea
celulele matricei vor fi egale cu 0, ceea ce
asta înseamnă că nu există nici „zero” nici
„cruce”, apoi în această celulă
matricea este scrisă 1 și în
PictureBox1
afișat
imaginea unei „cruci”, și dacă
valoarea celulei matricei va fi
este egal cu 1 atunci conține
„cruce” și 0 este scris în ea și
Se afișează o celulă goală.

PASUL 5. ADĂUGAREA CODULUI PENTRU OBIECTE PICTUREBOX

1
2
3
4
5
6
7
8
9

Pentru celulele rămase din câmp, adăugați codul
la fel ca în primul doar schimbându-se
Numărul obiectului PictureBox și adresa celulei
matrice.
EXEMPLU pentru a doua celulă:

În procedura când faceți clic pe un buton
adăuga
operator
ciclu
care verifică
toate celulele începând de la prima până la
prezența celulelor goale. Si daca
celula este goală,
apoi în ea
„zero” se scrie și anume în
celula matricei este scrisă -1.
Pentru comoditate în lucrările viitoare
variabile
eu,
j
care
folosit pentru a repeta bucle
Vom anunta pentru intregul formular.

PASUL 6. ADĂUGAREA CODULUI PENTRU BUTONUL WALK

Pentru a afișa zerouri
jocuri de noroc
camp
necesar
adăugați codul programului în corp
ciclu de verificare a celulelor pentru goluri.
Folosind o instrucțiune imbricată
ramificare
voi
avea loc
analiza adresei celulei matrice pentru
ieșire zero în corect
PictureBox.
Adăugăm, de asemenea, o declarație de pauză
pentru terminarea prematură
buclă atunci când găsiți gol
celule.

PASUL 6. ADĂUGAREA CODULUI PENTRU BUTONUL WALK

Pentru a indica starea jocului
este utilizat elementul de interfață
Eticheta 1. Din moment ce jucătorul se mișcă mereu
primul
Acea
la
descărcări
aplicatii
necesar
V
element
Eticheta 1
necesar
Reflectați
fraze „Tă
mișcare."
Pentru
acest
hai sa cream
variabil
Răspuns
care
Să atribuim această frază. A
la încărcarea formularului o variabilă
trebuie alocate elementului
Label1, pentru a crea necesarul
proceduri
necesar
dublu clic mai întâi
după formă

PASUL 7. ADĂUGAREA CODULUI DE PROGRAM PENTRU NOUL ARTICOL DE MENIU DE JOC

Când este apăsat pe comanda nou
jocul se va reseta
toate celulele matricei, înlocuind toate
„cruci” și „degete” pe
celule goale. De asemenea concluzia
Semnele „Mișcarea ta”.

PASUL 8. IEȘIȚI REZULTATUL JOCULUI

Pentru a verifica rezultatele mișcărilor
necesar
a analiza
conținutul rândurilor, coloanelor și
diagonalele. Dacă toate cele trei elemente
sunt egale cu 1, atunci aceasta este o victorie pentru jucător și
dacă trei -1 atunci aceasta este o înfrângere
jucător.
Este necesară verificarea victoriei
conduce
inainte de
progres
calculator,
A
Verifica
înfrângere după.
Ultima comandă a procedurii
rezultatele vor fi afișate pe ecran
progres.

PASUL 8. IEȘIȚI REZULTATUL JOCULUI

Cod de program pentru a verifica victoria utilizatorului:
if (znacheniyeYacheyki == 1 && znacheniyeYacheyki == 1 && znacheniyeYacheyki == 1) otvet = „Tu câștigi”;
if (znacheniyeYacheyki == 1 && znacheniyeYacheyki == 1 && znacheniyeYacheyki == 1) otvet = „Tu câștigi”;
if (znacheniyeYacheyki == 1 && znacheniyeYacheyki == 1 && znacheniyeYacheyki == 1) otvet = „Tu câștigi”;
if (znacheniyeYacheyki == 1 && znacheniyeYacheyki == 1 && znacheniyeYacheyki == 1) otvet = „Tu câștigi”;
if (znacheniyeYacheyki == 1 && znacheniyeYacheyki == 1 && znacheniyeYacheyki == 1) otvet = „Tu câștigi”;
if (znacheniyeYacheyki == 1 && znacheniyeYacheyki == 1 && znacheniyeYacheyki == 1) otvet = „Tu câștigi”;
if (znacheniyeYacheyki == 1 && znacheniyeYacheyki == 1 && znacheniyeYacheyki == 1) otvet = „Tu câștigi”;
if (znacheniyeYacheyki == 1 && znacheniyeYacheyki == 1 && znacheniyeYacheyki == 1) otvet = „Tu câștigi”;
Cod de program pentru a verifica victoria utilizatorului:
if (znacheniyeYacheyki == -1 & znacheniyeYacheyki == -1 & znacheniyeYacheyki == -1) otvet = „Ai pierdut”;
if (znacheniyeYacheyki == -1 & znacheniyeYacheyki == -1 & znacheniyeYacheyki == -1) otvet = „Ai pierdut”;
if (znacheniyeYacheyki == -1 & znacheniyeYacheyki == -1 & znacheniyeYacheyki == -1) otvet = „Ai pierdut”;
if (znacheniyeYacheyki == -1 & znacheniyeYacheyki == -1 & znacheniyeYacheyki == -1) otvet = „Ai pierdut”;
if (znacheniyeYacheyki == -1 & znacheniyeYacheyki == -1 & znacheniyeYacheyki == -1) otvet = „Ai pierdut”;
if (znacheniyeYacheyki == -1 & znacheniyeYacheyki == -1 & znacheniyeYacheyki == -1) otvet = „Ai pierdut”;
etichetă1.Text = răspuns;

PASUL 9 ÎMBUNĂTĂȚIREA JOCĂBILITĂȚII

Pentru a îmbunătăți redarea
în loc de ieșire în serie
la primele goale
celule de „zerouri”, implementăm
ieșire prin generator aleator
numere.
Pentru a face acest lucru, trebuie să adăugați
o variabilă logică
uslovie și schimbați tipul buclei din For
pe While, din moment ce nu știm
numărul exact de repetări
generator numere aleatorii Pa
nu va cădea într-o celulă goală.

MINISTERUL EDUCAȚIEI ȘI ȘTIINȚEI AL RUSIEI

instituție de învățământ bugetar de stat federal de învățământ profesional superior

Universitatea de Stat din Vologda

Departamentul de Automatizare și Inginerie Calculatoare

Notă explicativă a proiectului de curs la disciplina

Bazele programării și algoritmice

„Tic Tac Toe”

Efectuat elev al grupei EM-21

Butorova L.Yu.

Admis Rzheutskaya S. Yu.

INTRODUCERE

1. ANALIZA PROBLEMEI ȘI DETERMINAREA CERINȚELOR PENTRU PROGRAMUL DE DEZVOLTAT

1 Scopul programului, utilizatorii săi, funcțiile principale și obiectivele urmărite în timpul dezvoltării

2 Revizuirea programelor cunoscute care îndeplinesc funcții similare

3 Baza teoretică a dezvoltării

4 Selectarea instrumentelor de dezvoltare

PROIECTAREA PARTEA DIN DEZVOLTARE

1 Dezvoltarea interfeței cu utilizatorul

2.2 Dezvoltarea structurilor de date (în extern și RAM)

2.3 Dezvoltarea și analiza algoritmilor

IMPLEMENTAREA PROGRAMULUI ÎN LIMBAJ C++

1 Arhitectura programului

2 Selectarea componentelor vizuale și non-vizuale standard

REZULTATELE TESTULUI

CONCLUZIE

Bibliografie

Aplicații

INTRODUCERE

Tic-tac-toe este un joc logic între doi adversari pe un câmp pătrat de 3 pe 3 celule sau mai mare (până la un „câmp fără sfârșit”). Unul dintre jucători joacă cu „cruci”, al doilea – cu „degetele de la picioare”. Acest joc a devenit popular cu mult înainte de apariția computerelor, doar înainte de a fi jucat cu o bucată obișnuită de hârtie și un pix. Jocul tradițional chinezesc folosește pietre albe și negre.

In acest munca de curs Regulile de bază și dimensiunea standard a câmpului de joc (3x3 celule) sunt păstrate. Pentru comoditatea jocului, dreptul de a face prima mișcare este lăsat utilizatorului, adică „cruci”.

Tic Tac Toe este un program care este conceput pentru a distra utilizatorul, prin urmare interfața sa, în acest curs, este realizată într-un stil de joc cu o combinație de culori pozitive care intensifică partea emoțională a procesului de joc.

Există trei tipuri în joc: X versus 0 - utilizator versus utilizator, „nivelul 1 cu un computer” - pentru cei care tocmai învață elementele de bază ale jocului mondial și nivelul „nivelul 2 cu un computer” - pentru cei care sunt absolut încrezători în victoria lor. La nivelurile 1 și 2, există trei rezultate posibile: „câștigă”, „pierde” și „emiză”. Câștigurile sunt fixe dacă liniile verticale, orizontale sau diagonale sunt complet umplute cu cruci sau zerouri.

Dacă celulele libere ale terenului s-au terminat, dar nimeni nu câștigă, atunci jocul se consideră că se încheie cu o „remiză”.

1. ANALIZA PROBLEMEI ȘI DETERMINAREA CERINȚELOR PENTRU PROGRAMUL DE DEZVOLTAT

interfață încrucișată a programului

1.1 Scopul programului, utilizatorii acestuia, funcțiile principale și obiectivele urmărite în timpul dezvoltării

Scopul acestui program este, în primul rând, de a distra utilizatorii, de a lumina timpul de așteptare al unei persoane, deoarece orice muncă necesită odihnă, iar acest joc simplu vă va ajuta să vă relaxați și să vă luați mintea de la treburile de zi cu zi. „Tic Tac Toe” aparține, de asemenea, clasei de jocuri intelectuale și logice, care sunt concepute pentru a antrena gândirea logică, vă permit să vă concentrați atenția și să dezvoltați memoria.

Publicul țintă al utilizatorilor sunt copiii și adolescenții, precum și adulții. Principalele criterii de utilizare a produsului sunt capacitatea de a citi textul scris în program și capacitatea de a selecta sarcina necesară pentru computer folosind butoane.

Din aceasta putem concluziona că sarcinile principale sunt: sarcina de divertisment și sarcina de a dezvolta potențialul logic al unei persoane.

1.2 Revizuirea programelor cunoscute care îndeplinesc funcții similare

Pe Internet puteți găsi un număr mare de lucrări care implementează acest joc. În prezent, există mulți analogi ai acestui joc care s-au îndepărtat de standardele originale. Un exemplu de astfel de programe sunt „Tic-tac-toe pe un câmp nesfârșit” și „Tic-tac-toe 3D”. De asemenea, în multe jocuri, „crucile” și „degetele de la picioare” sunt înlocuite cu alte simboluri, cum ar fi, de exemplu, „pietre”.

Proiectul meu de curs este o aplicație pentru computer. Jocul este destinat atât unui utilizator, al cărui adversar este inteligența artificială (sau un computer), cât și pentru doi utilizatori. Este prezentat pe un teren clasic 3x3.

Cel mai interesant și neobișnuit, după părerea mea, a fost jocul „Tic Tac Toe 3D”. De aceea l-am ales pentru comparație.

3D tic-tac-toe este mult mai interesant decât pe hârtie sau pe o tablă obișnuită. Există mai multe oportunități de a câștiga și de a pierde, iar remizele sunt mai puțin frecvente. Puteți juca singur - împotriva computerului - sau împreună cu un prieten. Și cel mai neobișnuit lucru aici este că, pentru a câștiga, puteți face o combinație de trei bile de culoarea dvs. (negru sau alb) nu numai la orice nivel, ci și de-a lungul planului pereților și chiar în diagonală pe întregul câmp ( Fig. 1.1).

Orez. 1.1

Dintre varietatea mare de jocuri pe o temă similară, putem evidenția în fiecare lucrare o implementare unică a planului. Fiecare proiect diferă de alții prin individualitatea sa.

1.3 Baza teoretică a dezvoltării

Analiză

Pentru fiecare dintre părți, există algoritmi cunoscuți care garantează egalitatea în jocul oricărui adversar și, dacă adversarul greșește, îi permit să câștige. Deci jocul este într-o stare „moartea nimănui”<#"877528.files/image002.gif">

Fig.1.2. Arborele situațiilor de joc

Un arbore parțial al situațiilor de joc este prezentat în Fig. 1.2 pentru jocul tic-tac-toe. Un arbore de situații de joc pentru jocul tic-tac-toe, în care jucătorul pentru „cruci” merge primul și acționează conform algoritmului de mai sus, iar jucătorul pentru „degetele de la picioare” poate face tot ce vrea (și un vârf este dat pentru o acțiune rațională și pentru o acțiune irațională, adică orice alta), este format din 50 de noduri.

1.4 Selectarea instrumentelor de dezvoltare

Pentru a ne atinge obiectivele, avem nevoie de un mediu integrat de dezvoltare a aplicațiilor. Prin urmare, dezvoltarea proiectului a fost realizată în mediul de programare Microsoft Visual Studio 2008.

Microsoft Visual Studio este o linie de produse Microsoft , inclusiv un mediu de dezvoltare integrat software și o serie de alte instrumente. Aceste produse vă permit să vă dezvoltați pe bază de consolă aplicatii și aplicații GUI , inclusiv suport pentru tehnologia Windows Forms , precum și site-uri web , servicii web ca la nativ , și controlat coduri pentru toate platformele acceptate de Windows ,Windows Mobile ,Windows CE , .Cadru net , Xbox , Windows Phone .NET Compact Framework și Silverlight .

2. PROIECTAREA PARTEA DIN DEZVOLTARE

2.1 Dezvoltarea interfeței cu utilizatorul

Atunci când creați o aplicație de jocuri, este necesar să luați în considerare una dintre componentele principale ale succesului produsului - interfața. Interfața cu utilizatorul a programului trebuie, în primul rând, să fie înțeleasă și atractivă pentru utilizator. Trebuie să încercați să eliminați toate momentele care vor distrage atenția utilizatorului sau îi vor provoca disconfort. Întreaga interfață a programului poate fi împărțită în două componente.

) Meniul principal al programului

Orez. 2.1 - Meniul principal al programului

Meniul principal este conceput pentru a permite utilizatorului să se alăture atmosferei de joc, astfel încât interfața este concepută în culori pline de culoare, jucăușe. Prin intermediul meniului puteți merge la terenul de joc, puteți vizualiza regulile jocului sau puteți părăsi jocul.

) Loc de joaca

Fig 2.2 - Teren de joc

Terenul de joc conține zona imediată de joc, unde jucătorul și computerul își plasează pictogramele. Înainte de a începe jocul, utilizatorul trebuie să selecteze tipul de joc precum „X vs 0”, „1 nivel cu computer” sau „2 nivel cu computer”, altfel programul va da un mesaj despre ce trebuie să facă. Un buton care va ajuta jucătorul să revină la meniul principal. La sfârșit, vor apărea ferestre suplimentare pentru a informa participantul despre rezultatele meciului.

Orez. 2.3 - ferestre suplimentare de rezultat al jocului

2.2 Dezvoltarea structurilor de date (în extern și RAM)

RAM este utilizată pentru o matrice unidimensională constând din 9 elemente care stochează stările terenului de joc, unde fiecare celulă a matricei corespunde unei celule de pe terenul de joc. Memoria este cheltuită și pe variabile statice: numărul nivelului, ordinea turei.

Este nevoie de 803 KB de memorie liberă pentru a funcționa.

.3 Dezvoltarea și analiza algoritmilor

Pentru a implementa algoritmul de gândire al jocului, trebuie să setați o matrice statică gcnew (9); în care vor fi stocate stările terenului de joc, unde fiecare celulă a matricei corespunde unei celule. „0” - corespunde unei celule goale, dacă un jucător s-a mutat în celulă, adică „X”, se înregistrează valoarea „1” și dacă computerul a făcut o mișcare, adică „O”, valoarea este „2”. Inițial, toate elementele matricei sunt egale cu „0”. Este necesar să setați variabila statică lvl, care stochează datele de nivel. Există 3 niveluri în total în acest joc: lvl ia valoarea „1” dacă utilizatorul a ales tipul de joc „X vs O”, valoarea „2” dacă „nivelul 1 cu un computer” și valoarea „3 „ dacă „nivelul 2 cu un computer” „ Variabila jucător stochează ordinea rândului („adevărat” este rândul jucătorului, „fals” este rândul computerului). Deoarece dreptul de a face prima mutare este acordat utilizatorului, la începutul jocului player = adevărat. Variabila statică flag stochează informații despre dacă există sau nu celule goale pe terenul de joc: dacă flag = adevărat - adică fals - nu există celule goale. Algoritmul de verificare trebuie să conțină o iterație a parametrilor matricei x și să prezinte propria soluție, care va fi optimă pentru continuarea jocului. Acest program are 2 niveluri de joc cu un computer. La nivelul 1, sarcina computerului este să nu învingă adversarul. De aceea această funcție returnează o valoare aleatorie a celulei în care va merge computerul. Codul pentru acest algoritm este prezentat în [Anexa 1]. Figura 2.4 prezintă schema bloc a implementării codului.

Cea mai câștigătoare mișcare la începutul jocului este deplasarea în centrul terenului. În funcția dif_level() se verifică la început o condiție: dacă jucătorul nu a mers în câmpul central, atunci computerul merge acolo. În caz contrar, dacă jucătorul a mers în centru, atunci funcția check(2) este apelată pentru a verifica combinația de computer și, dacă există o oportunitate de a câștiga, atunci returnează numărul celulei. Dacă computerul nu poate câștiga la următoarea mișcare, atunci funcția check(1) este numită: verificarea combinației jucătorului. Numărul celulei în care jucătorul ar fi câștigat dacă pariul este returnat. Dacă nu există o astfel de combinație, atunci funcția low_level() este apelată.

Fig.2.4. - Diagramă bloc

Fig.2.5. - Diagramă bloc

3. IMPLEMENTAREA PROGRAMULUI ÎN LIMBAJ C++

.1 Arhitectura programului

Acest program implementează 3 forme: meniul principal (Fig. 2.1.), terenul de joc (Fig. 2.2) și câmpul de ajutor (reguli de joc); 12 panouri, dintre care 9 sunt principale. De asemenea, la sfârșitul jocului, apare un PictureBox cu rezultatul, sunt 5 în total (Figura 2.3).

Puteți folosi ca bază manevrele de clic pe panou, dintre care sunt exact 9 pe terenul de joc. Fiecare handler apelează mai multe funcții. La început există o condiție, dacă utilizatorul selectează tipul de joc „X versus 0”, celulele sunt pur și simplu umplute cu valorile 1 sau 2 (cruce sau zero). Urmează funcțiile: indicarea progresului (CrossZero()), care schimbă crucea la zero și invers, blocarea celulelor ocupate checkingArray(), găsirea câștigătorului(). Funcția winner() ia în considerare toate opțiunile de câștig posibile, așa că dacă unul dintre jucători aliniază 3 dintre piesele sale (o cruce sau un zero) vertical, orizontal sau diagonal, el va câștiga. În caz contrar, dacă câmpul este plin, dar niciunul dintre jucători nu s-a aliniat, atunci este apelată funcția de verificare a egalității (_friend()), care verifică dacă au rămas celule libere pe teren sau nu. Dacă fr = true, atunci nu există celule libere pe câmp. Dacă valoarea sa schimbat, înseamnă că există o celulă liberă pe câmp.

A doua condiție funcționează dacă este selectat al doilea sau al treilea tip de joc. Apoi funcția în care s-a făcut mișcarea computerului se numește: move(int n). Acesta transmite numărul celulei pe care a făcut clic jucătorul. Urmează funcțiile: indicarea progresului (CrossZero()), blocarea celulelor ocupate checkingArray(). Apoi este apelată funcția winner(), care verifică dacă jucătorul a câștigat cu această mișcare sau nu. Dacă nu, atunci prezența celulelor libere este verificată. Dacă există celule libere, atunci computerul se mișcă. În continuare, în funcție de ce nivel a ales jucătorul „1” sau „2”, se numesc următoarele funcții: low_level(), dif_level(). Funcția low_level() selectează unde să plaseze zero în mod aleatoriu, iar funcția dif_level() prezintă un algoritm special pentru ca computerul să câștige. Urmează funcțiile: indicarea progresului (CrossZero()), blocarea celulelor ocupate checkingArray(). Apoi este apelată funcția winner(), care verifică dacă computerul a câștigat cu această mișcare sau nu. Dacă nu, atunci prezența celulelor libere este verificată. Dacă există celule libere, atunci jucătorul se mișcă.

.2 Selectarea componentelor vizuale și non-vizuale standard

Pentru implementarea acestei lucrări au fost selectate următoarele componente:

1) Form1, cu parametrii dați Text=Tic-Tac-Toe, ControlBox=False

2) f2, cu parametrii specificați BackColor, Text=Game

) comboBox1 cu parametrii Items specificați:

X vs 0

Nivelul 1 cu calculator

Nivelul 2 cu computer

4) panou, cu parametri BackColor specificați și valori diferite pentru parametrii Vizibil și Activat. Pentru unele panouri au fost scrise evenimente precum Click.

5), cu parametrii specificați Font, Fore Color, BackColor, Text, pentru toate butoanele au fost scrise evenimente precum Click.

6) etichetă, cu parametrii specificați BackColor, Font, Fore Color, Text.

) pictureBox, cu parametrii specificați Image, SizeMode= StretchImage.

) textBox, cu parametrii specificați BackColor, Font, Fore Color, Text=" ”.

4. REZULTATELE TESTULUI

Să testăm programul trecând prin 3 tipuri de jocuri.

Să încercăm acțiunile butoanelor din meniul principal. Butoanele funcționează corect. Să încercăm să începem jocul fără a alege un tip de joc. Programul afișează un mesaj de eroare și vă solicită să selectați tipul de joc (Fig. 4.1).

Fig.4.1.

Să alegem 1 tip de joc - „X versus 0”, adică. utilizator vs utilizator. În această etapă a jocului, utilizatorul se poate juca și cu el însuși. (Fig.4.2)

Fig.4.2.

În timpul jocului „Nivelul 1 cu computerul”, computerul nu își stabilește obiectivul de a câștiga participantul. El pune doar zerouri locuri libere câmpuri. În această etapă, utilizatorul poate învinge cu ușurință computerul. Deși la acest nivel sunt posibile și alte opțiuni de desfășurare a evenimentelor.

Fig.4.3.

Tip de joc: „Nivelul 2 cu computer”. În această etapă, jocul analizează toate mișcările și încearcă să aleagă cea mai optimă mișcare. Și aici toate cele trei scenarii sunt posibile, pentru că Computerul face prima mutare către orice celulă liberă. Cel mai adesea jocul se rezumă la egalitate.

Fig.4.4.

Programul rulează cu succes pe toate variantele de testare, fără erori.

CONCLUZIE

Putem spune cu încredere că sarcina stabilită la începutul lucrării a fost finalizată. În timpul dezvoltării, a fost planificat și dezvoltat un proiect pentru un remix al celebrului joc „Tic Tac Toe”. Jocul îndeplinește cerințele specificate și își îndeplinește funcțiile. Implementat în lucrare Tipuri variate jocuri și niveluri de dificultate.

În timpul lucrărilor, noi metode de programare au fost stăpânite într-un mediu de dezvoltare integrat. Cunoștințele vechi de lucru cu limbajul C++ au fost consolidate. În pregătirea lucrărilor de curs, au fost analizate diverse metode și algoritmi de implementare a acestui joc.

În ciuda simplității aparente a acestui program, este plin de o serie de dificultăți care sunt implementate folosind toate tehnicile de bază ale Visual C++.

Caracteristicile acestui program sunt:

Algoritm clar construit;

Interfață intuitivă;

Ușor de folosit;

Manual de utilizare destul de clar;

Fără suplimente inutile.

BIBLIOGRAFIE

1. http://www.pravilaigr.ru/xo.php

2. http://2igroka.com/stuff/sportivnye/krestiki_noliki_3d/15-1-0-14

3. https://www.draw.io/

Http://pol-video.ru/QPW9QHEO2GU/uroki_s_krestiki-noliki_ch1.html

ANEXA 1

private: int low_level())(// procedură pentru un adversar ușor;::Random^ rand = gcnew System::Random();(= rand->Next(0,8);

) în timp ce (x[r] != 0);r;

ANEXA 2

private: bool check(int n)(k = -1;// verifică toate combinațiile și returnează mutarea corectă(x == n) (((x == n)&&(x == 0)) k =2; ((x == n)&&(x == 0)) k =1;((x == n)&&(x == 0)) k =6;((x == n)&&(x == 0)) k =3;((x == n)&&(x == 0)) k =8;((x == n)&&(x == 0)) k =4;

)(x == n) (((x == n)&&(x == 0)) k =0;((x == n)&&(x == 0)) k =7;((x = = n)&&(x == 0)) k =4;

)(x == n) (((x == n)&&(x == 0)) k =4;((x == n)&&(x == 0)) k =6;((x = = n)&&(x == 0)) k =8;((x == n)&&(x == 0)) k =5;

)(x == n) (((x == n)&&(x == 0)) k =0;((x == n)&&(x == 0)) k =5;((x = = n)&&(x == 0)) k =4;

)(x == n) (((x == n)&&(x == 0)) k =0;((x == n)&&(x == 0)) k =3;((x = = n)&&(x == 0)) k =1;((x == n)&&(x == 0)) k =2;

)(x == n) (((x == n)&&(x == 0)) k =2;

)(x == n) (((x == n)&&(x == 0)) k =8;((x == n)&&(x == 0)) k =7;

)(x == n) (((x == n)&&(x == 0)) k =6;

)(k!=-1) returnează adevărat;altfel returnează fals;

ANEXA 3

privat: int dif_level())(//inamic dificil

//return check(2);(x == 0) return (4);(check(2)) return k; else (bifează(1)) returnează k; else low_level();

APLICARE 4

privat: void CrossZero())(// schimbă crucea la zero (indicator de progres)(player) (->Vizibil = adevărat;->Vizibil = fals;

) else (->Vizibil = adevărat;->Vizibil = fals;

): void checkingArray())(// funcția de a verifica dacă există ceva într-o celulă, dacă există, atunci nu mai puteți da clic pe această celulă.(x == 1) (panel1->BackgroundImage = panel11->BackgroundImage ;panel1- >Activat = fals;)(x == 2) (panel1->BackgroundImage = panel10->BackgroundImage;panel1->Activat = fals;)(x == 1) (panel2->BackgroundImage = panel11->BackgroundImage ;panel2- >Activat = fals;)(x == 2) (panel2->BackgroundImage = panel10->BackgroundImage;panel2->Enabled = false;)(x == 1) (panel3->BackgroundImage = panel11->BackgroundImage ;panel3- >Activat = fals;)(x == 2) (panel3->BackgroundImage = panel10->BackgroundImage;panel3->Enabled = false;)(x == 1) (panel4->BackgroundImage = panel11->BackgroundImage ;panel4- >Activat = fals;)(x == 2) (panel4->BackgroundImage = panel10->BackgroundImage;panel4->Enabled = false;)(x == 1) (panel5->BackgroundImage = panel11->BackgroundImage ;panel5- >Activat = fals;)(x == 2) (panel5->BackgroundImage = panel10->BackgroundImage;panel5->Enabled = false;)(x == 1) (panel6->BackgroundImage = panel11->BackgroundImage ;panel6- >Activat = fals;)(x == 2) (panel6->BackgroundImage = panel10->BackgroundImage;panel6->Enabled = false;)(x == 1) (panel7->BackgroundImage = panel11->BackgroundImage ;panel7- >Activat = fals;)(x == 2) (panel7->BackgroundImage = panel10->BackgroundImage;panel7->Enabled = false;)(x == 1) (panel8->BackgroundImage = panel11->BackgroundImage ;panel8- >Activat = fals;)(x == 2) (panel8->BackgroundImage = panel10->BackgroundImage;panel8->Enabled = false;)(x == 1) (panel9->BackgroundImage = panel11->BackgroundImage ;panel9- >Activat = fals;)(x == 2) (panel9->BackgroundImage = panel10->BackgroundImage;panel9->Activat = fals;)

): bool winner())(// se verifică câștigătorul și se blochează toate celulele rămase.

//steagul bool = fals;(((x == x)&&(x == x)&&(x == 2)) || ((x == x)&&(x == x)&&(x = = 2)) || ((x == x)&&(x == x)&&(x == 2)) || ((x == x)&&(x == x)&&(x == 2) )) || ((x == x)&&(x == x)&&(x == 2)) || ((x == x)&&(x == x)&&(x == 2)) || ((x == x)&&(x == x)&&(x == 2)) || ((x == x)&&(x == x)&&(x == 2)))( (lvl==1) ( imaginePo->Vizibil = adevărat;)(picturePr->Vizibil = adevărat;)->Activat = fals;->Activat = fals;->Activat = fals;->Activat = fals;-> Activat = fals;->Activat = fals;->Activat = fals;->Activat = fals;->Activat = fals;adevărat;

)(((x == x)&&(x == x)&&(x == 1)) || ((x == x)&&(x == x)&&(x == 1)) || ((x == x)&&(x == x)&&(x == 1)) || ((x == x)&&(x == x)&&(x == 1)) || (( x == x)&&(x == x)&&(x == 1)) || ((x == x)&&(x == x)&&(x == 1)) || ((x == = x)&&(x == x)&&(x == 1)) || ((x == x)&&(x == x)&&(x == 1)))((lvl==1) ( imaginePx->Vizibil = adevărat;)(picturePobeda->Vizibil = adevărat;)->Activat = fals;->Activat = fals;->Activat = fals;->Activat = fals;->Activat = fals;-> Activat = fals;->Activat = fals;->Activat = fals;->Activat = fals;adevărat;

): void _friend())(fr = true;(int i = 0; i< 9; i++) if (x[i] == 0) {fr = false; break;}(fr) { pictureN->Vizibil = adevărat;)

): void mutare(int n)(// funcția mutare computer= false;[n] = 1;= !player;();();(winner()) () ((int i = 0; i< 9; i++) if (x[i] == 0) flag = true;(flag){(lvl == 2) = 2; = 2;= !player;();();();

): System::Void button1_Click(System::Object^ expeditor, System::EventArgs^ e) (// joc nou>Vizibil = fals;>Vizibil = fals;>Vizibil = fals; >Vizibil = fals; >Vizibil = false; = comboBox1->Text;(typeGame == "")(::Show("Selectați mai întâi tipul de joc!");

) else ((typeGame == „X versus 0”) lvl = 1;(typeGame == „primul nivel cu un computer”) lvl = 2;(typeGame == „nivelul 2 cu un computer”) lvl = 3;( ); = adevărat;(int i = 0; i< 9; i++) x[i] = 0;->BackgroundImage = panel12->BackgroundImage;->BackgroundImage = panel12->BackgroundImage;->BackgroundImage = panel12->BackgroundImage;->BackgroundImage = panel12->BackgroundImage;->BackgroundImage = panel12->BackgroundImage;->BackgroundImage;->BackgroundImage->BackgroundImage = panel12->BackgroundImage; BackgroundImage;->BackgroundImage = panel12->BackgroundImage;->BackgroundImage = panel12->BackgroundImage;->BackgroundImage = panel12->BackgroundImage;->Enabled = true;->Enabled = true;->Enabled = true;->Enabled = adevărat;->Activat = adevărat;->Activat = adevărat;->Activat = adevărat;->Activat = adevărat;->Activat = adevărat;

): System::Void panel1_MouseClick(System::Object^ expeditor, System::Windows::Forms::MouseEventArgs^ e) (n = 0;(lvl == 1)((player)( = 1;

)= !player;();();();

): System::Void panel2_MouseClick(System::Object^ expeditor, System::Windows::Forms::MouseEventArgs^ e) (n = 1;(lvl == 1)((player)( = 1;

)= !player;();();();