mājas › Uzstādīšana un konfigurēšana › Tik-tac-toe spēles izveide. Attīstības teorētiskie pamati

Tik-tac-toe spēles izveide. Attīstības teorētiskie pamati

Sveicināti, dārgie draugi! Šajā nodarbībā es parādīšu, kā javascript var izveidot pārlūkprogrammas spēli - tic-tac-toe! Jūs visi zināt, kas ir šī spēle un kā to spēlēt, taču atgādināšu vēlreiz:

Tic-tac-toe ir loģiska spēle starp diviem spēlētājiem laukumā, kurā ir 3 x 3 šūnas (iespējams, lielāka). Viens spēlē ar “krustiņiem”, bet otrs ar “pirkstiem”.

P.S. tāpat kā visās līdzīgās javascript nodarbībās, raksta beigās varat lejupielādēt avota failu, kā arī redzēt darba rezultātu demonstrācijas piemērā!

Veidojamās spēles apraksts

Apskatīsim spēles funkcijas:

spēle sākas uzreiz pēc lapas ielādes;
tiesības iet pirmajam tiek izvēlētas nejauši (vai nu tu sāc staigāt, vai dators);
zīme, uz kuru jūs liksit, ir izvēlēta nejauši (krusts vai nulle);
ja spēlētājs uzvar, laimesta simboli (krustiņu vai nulles josla) ir iezīmēti zaļā krāsā;
ja spēlētājs zaudē datoram, josla tiek iezīmēta sarkanā krāsā;
Virs lauka ir informācijas rinda, kurā tiek parādīts rezultāts (uzvara vai sakāve).

Loģika

Es neizdomāju sarežģītus (universālus) algoritmus spēles laukumam 3 x 3, es izvēlējos citu ceļu - brutālu spēku! (vairāk par to nedaudz vēlāk). Esmu identificējis trīs galvenos secīgos posmus, uz kuriem balstās visa loģika:

1. posms: pārbaudīt, vai spēlētājs ir uzvarējis?

Šajā posmā mēs pārbaudām, vai ir 3 šūnas (vienā rindā), kas ir aizpildītas ar vienādiem spēlētāja simboliem (krustiņiem vai nullēm). Tie. neatkarīgi no tā, kāds ir gājiens (pat pirmais), mēs vienmēr vispirms pārbaudām, vai spēlētājs ir uzvarējis. Uzvara izskatās šādi:

2. posms: pārbaudiet – vai dators var uzvarēt ar nākamo gājienu?

Šajā posmā mēs meklējam līniju, kurā būtu 2 datora aizpildītas šūnas un viena tukša - tas ir, mēs cenšamies uzvarēt spēlētāja neuzmanības dēļ. Šādi izskatās sakāve (t.i., datora uzvara):

3. posms: mēs neļaujam jums uzvarēt!

Šeit mēs meklējam to pašu rindu kā otrajā posmā, tikai 2 šūnas ir jāaizpilda ar spēlētāja spēles zīmēm, tas ir, šajā posmā mēs neļaujam datoram zaudēt, ievietojot zīmi tukšā šūnā. Katrs no posmiem apzīmē neatkarīgu funkciju — to var redzēt tālāk esošajā js kodā.

Īstenošana

Spēles laukuma izkārtojums ir ļoti vienkāršs - galvenajā blokā ir informācijas rinda (klase - rezultāts) un 9 bloki, kas ir šūnas (klase - bloks) HTML šūnu izkārtojums:

Tava kārta!

Papildu klases šūna ir nepieciešama, lai spēles laukumā precīzi identificētu vēlamo šūnu. CSS stili spēles laukumam:

Krestiki_noliki( platums: 306 pikseļi; piemale: 0 auto; ) .krestiki_noliki .block( platums: 100 pikseļi; augstums: 100 pikseļi; apmale: 1px solid #ccc; kursors: rādītājs; peldēšana: pa kreisi; teksta līdzināšana: centrs; fonta lielums: 100 pikseļi; līnijas augstums: 94 pikseļi;)

Tagad apskatīsim visu JS kodu, pēc kura es runāšu par galvenajiem punktiem:

$(dokuments).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"]; //Noteikt spēlētāja uzvaras funkciju check_3_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($("."+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; } }); });

Pirmkārt, mēs deklarējam mainīgos: znak_user - šajā mainīgajā mēs saglabājam zīmi, ar kuru lietotājs spēlēs (pēc noklusējuma tur tiek saglabāta nulle - tas ir angļu lodziņš "O"). znak_comp - šajā mainīgajā mēs saglabājam zīmi, ar kuru dators spēlēs (pēc noklusējuma tur tiek saglabāts krustiņš - tas ir angļu lodziņš "X").

Loģika ir šāda: ja nejaušais skaitlis ir lielāks par 3, tad dators spēlē ar nullēm, un tas (dators) veic pirmo gājienu.

Jūs varat mainīt šo loģiku pēc iespējas ērtāk, piemēram, varat izveidot vairākus nejaušus skaitļus, lai būtu vairāk iespēju, kurš būs pirmais un kādas zīmes. exit_flag - šis karogs (mainīgais) ir atbildīgs par iziešanu no funkcijas, tas ir, piemēram, kad dators jau ir veicis savu gājienu, un jums ir jāiziet no funkcijas un jānodod gājiens atskaņotājam. win_user_array — šis masīvs saglabā visas uzvarošās opcijas šūnu aizpildīšanai. Lai tas būtu skaidrs, apskatīsim šo attēlu:

Katrs masīva elements ir trīs skaitļu virkne, kas ir uzvaroša kombinācija, tas ir, piemēram, ja jūs aizpildīsit šūnas zem cipariem 1, 2 un 3, tad notiks uzvara (vai sakāve). Kā redzat, pavisam ir 8 laimestu iespējas, mūsu uzdevums ir iziet cauri visām šīm iespējām. Tālāk nāk 3 funkcijas:

pārbaudīt_3_lietotājs();
check_2_comp();
pārbaudīt_2_lietotājs();

Šo funkciju mērķis ir aprakstīts (trīs posmos) sadaļā Loģika (iepriekš). Šīs funkcijas tiek izsauktas, noklikšķinot uz jebkuras lauka šūnas. Katrai no funkcijām tiek nodots parametrs (znak) - tā ir spēlētāja vai datora zīme (krustiņš vai nulle), piemēram, funkcijai, kas nosaka spēlētāja uzvaru (check_3_user), mēs nododam spēlētāja zīmi secībā. lai uz vienas līnijas atrastu 3 identiskas zīmes.

Pēc trim funkcijām (ja dators vēl nav veicis kustību), dators aizpilda vienu no brīvajām šūnām. Šeit jūs varat sarežģīt spēli, piemēram, izveidojot to tā, ka, ja centrālā šūna ir brīva (šūnas numurs 5), tad vispirms veiciet likmi tajā; ja tā ir aizņemta, tad veiciet likmi vienā no brīvajiem stūriem (tie ir šūnas Nr. 1, 3, 7 un 9) un tā tālāk - kopumā šeit tas ir atkarīgs no jūsu ieskatiem.

Tas principā ir viss, kas nepieciešams, lai izveidotu šādu spēli.

Tagad varat skatīties spēli, izmantojot demonstrācijas piemēru, un lejupielādēt avota failu (kopā 1 fails).

06/08/2018 - paldies par uzmanību vēstules autoram: Patvakanam Baghdasaryan, kļūda ir novērsta, kad datoram bija vairākas iespējamie varianti uzvaras un visi viņa uzvaras gājieni tika nokrāsoti (no 4 uz 6 šūnām, nevis 3).

Tas arī viss man, ceru, ka šī nodarbība jums bija noderīga, novēlu veiksmi, čau!

Kā uzrakstīt robotu, kuru nevar pārspēt ar tic-tac-toe, vai Ievads minimax noteikumā

Pilnīgi iespējams, ka pēc simtiem tic-tac-toe spēļu esat domājis: kāds ir optimālais algoritms? Bet, ja esi šeit, tad droši vien arī mēģināji uzrakstīt šīs spēles realizāciju. Mēs dosimies tālāk un uzrakstīsim botu, kuru nebūs iespējams pārspēt ar tic-tac-toe. Paredzot jūsu jautājumu “kāpēc?”, mēs atbildēsim: pateicoties algoritmam.

Tāpat kā profesionāls šahists, šis algoritms aprēķina pretinieka darbības vairākus gājienus uz priekšu – līdz tas sasniedz spēles beigas, vai tā ir uzvara, sakāve vai neizšķirts. Šajā galīgajā stāvoklī AI piešķirs sev pozitīvu punktu skaitu (mūsu gadījumā +10) par uzvaru, negatīvu (-10) par zaudējumu un neitrālu (0) par neizšķirtu.

Tajā pašā laikā algoritms veic līdzīgus aprēķinus spēlētāja gājieniem. Tas izvēlēsies gājienu ar augstāko punktu skaitu, ja AI kustas, un gājienu ar viszemāko, ja spēlētājs kustas. Izmantojot šo stratēģiju, minimax izvairās no sakāves.

Mēģiniet spēlēt šo spēli.

Minimax algoritmu visvieglāk raksturo kā rekursīvu funkciju, kas:

atgriež vērtību, ja tiek atrasts galīgais stāvoklis (+10, 0, -10),
iet cauri visām tukšajām šūnām uz lauka,
izsauc minimax funkciju katram no tiem (rekursija),
novērtē iegūtās vērtības
un atdod labāko.

Ja neesat pazīstams ar rekursiju, jums vajadzētu noskatīties šo lekciju no Hārvardas CS50 kursa:

Lai saprastu, kā minimax darbojas, uzrakstīsim tā ieviešanu un modelēsim tā uzvedību. Mēs to aplūkosim nākamajās divās sadaļās.

Minimax ieviešana

Apskatīsim situāciju, kad spēle tuvojas beigām (skatiet attēlu zemāk). Tā kā minimax iet cauri visiem iespējamajiem spēles stāvokļiem (un to ir simtiem tūkstošu), ir jēga apsvērt beigu spēli - tādā veidā mums būs jāizseko mazākam rekursīvo funkciju izsaukumu skaitam (kopā 9).

Ļaujiet AI spēlēties ar krustiem, cilvēks - ar nullēm.

Lai atvieglotu darbu ar lauku, deklarēsim to kā 9 elementu masīvu ar vērtībām, kas vienādas ar šūnu saturu. Aizpildīsim to ar krustiņiem un pirkstiem, kā attēlā augstāk, un nosauksim to par origBoard.

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

Tālāk mēs deklarēsim mainīgos lielumus aiPlayer un huPlayer un piešķirsim tiem attiecīgi vērtības "X" un "O".

Turklāt mums būs nepieciešama funkcija, kas meklē uzvarošās kombinācijas un atgriež patieso vērtību, ja meklēšana ir veiksmīga, un funkcija, kas saglabā pieejamo šūnu indeksus.

/* sākotnējais stāvoklis dēļi O | | X --------- X | | X --------- | O | O */ var origBoard = [“O”,1 ,”X”,”X”,4 ,”X”, 6 ,”O”,”O”]; // persona var huPlayer = “O”; // AI var aiPlayer = “X”; // atgriež tukšo šūnu indeksu sarakstu uz tāfeles funkcijas emptyIndices(board)( return board.filter(s => s != "O" && s != "X"); ) // uzvarošās kombinācijas, ņemot vērā indeksu funkcija win(board, player)( if((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) || | = spēlētājs)) (atgriezt patiesu; ) else (atgriezt nepatiesu; ) )

Tātad, definēsim minimax funkciju ar diviem argumentiem: newBoard un player. Tad mēs uz lauka atradīsim brīvo šūnu indeksus un nodosim tos availSpots mainīgajam.

// galvenā minimax funkcija funkcija minimax(newBoard, player)( // pieejamās šūnas var availSpots = emptyIndices(newBoard);

Turklāt mums ir jāseko līdzi galīgajiem stāvokļiem un jāatgriež atbilstošās vērtības. Ja uzvar “nulle”, jums jāatgriež -10, ja “krusts” - +10. Ja availSpots masīva lielums ir nulle, tad brīvu šūnu nav, spēle beigsies neizšķirti un ir jāatgriež nulle.

// pārbauda termināļa stāvokli (win/loss/draw) //un attiecīgi atgriež vērtību if (win(newBoard, huPlayer))( return (score:-10); ) else if (win (newBoard, aiPlayer)) ( atgriešanās (rezultāts:10); ) else if (availSpots.length === 0)( return (score:0); )

Pēc tam jums ir jāsavāc punkti no katras tukšās šūnas. Lai to izdarītu, mēs izveidosim kustību masīvu un cilpā iziesim cauri visām tukšajām šūnām, pārvietošanas objektā ievietojot katras kustības indeksus un punktus.

Pēc tam mēs iestatām tukšās šūnas indeksu, kas origBoard tika saglabāts kā skaitlis, vienāds ar pārvietošanas objekta indeksa īpašību. Pēc tam mēs kā pašreizējais spēlētājs dosimies uz jaunā lauka newBoard tukšu šūnu un izsauksim funkciju minimax no otra atskaņotāja un no tā izrietošo lauku newBoard . Pēc tam jums jāievieto pārvietošanas objekta rezultāta rekvizīts objektam, ko atgriež funkcija minimax.

Ja minimax neatrod termināla stāvokli, tas turpina rekursīvi virzīties dziļāk spēlē, līdz sasniedz termināla stāvokli. Pēc tam šī rekursijas “līmeņa” punktus tā pārnes uz vienu līmeni augstāk.

Visbeidzot, funkcija atiestata izmaiņas uz newBoard un ievieto pārvietošanas objektu kustību masīvā.

// masīvs visu objektu glabāšanai var moves = ; // cilpa caur pieejamajām šūnām for (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); }

Pēc tam Minimax ir jāizvēlas vislabākā kustība no kustību masīva. Viņam ir vajadzīga gājiens ar augstāko punktu skaitu, ja AI kustas, un ar zemāko, ja tas ir cilvēka gājiens. Tādējādi, ja atskaņotāja vērtība ir aiPlayer , algoritms inicializē bestScore mainīgo līdz ļoti mazam skaitlim un iziet cauri kustību masīvam: ja gājiena rezultāts ir vairāk nekā bestScore , algoritms atceras šo gājienu . Gājienu ar vienādiem punktiem gadījumā algoritms atceras pirmo.

Gadījumā, ja spēlētājs ir vienāds ar huPlayer, viss ir līdzīgi - tikai tagad bestScore tiek inicializēts uz lielu skaitu, un minimax meklē gājienu ar vismazāko punktu skaitu.

Rezultātā minimax atgriež bestMove saglabāto objektu.

// ja tas ir AI gājiens, veiciet cilpas kustības un atlasiet gājienu ar visvairāk punktu var bestMove; if(player === aiPlayer)( var bestScore = -10000; for(var i = 0; i< moves.length; i++){ if(moves[i].score >bestScore)(labākaisScore = kustības[i].score; bestMove = i; ) )else( // pretējā gadījumā veiciet cilpu starp gājieniem un atlasiet gājienu ar vismazāko punktu 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ākamajā sadaļā mēs simulēsim mūsu programmu, lai saprastu, kā tā darbojas.

Minimax darbībā

Izmantojot zemāk esošo diagrammu, mēs analizēsim algoritma soli pa solim modeli.

Piezīme: diagrammā lieli skaitļi norāda funkcijas izsaukuma sērijas numuru, un līmeņi norāda, cik kustību algoritms ir veicis uz priekšu.

OrigBoard un aiPlayer tiek ievadīti algoritmā. Tas izveido sarakstu ar trim atrastajām tukšajām šūnām, pārbauda stāvokļa galīgumu un iziet cauri visām tukšajām šūnām. Pēc tam algoritms maina newBoard, ievietojot aiPlayer pirmajā tukšajā laukumā. Pēc tam tas izsauc sevi no newBoard un huPlayer un gaida otro zvanu, lai atgrieztu vērtību.
Kamēr joprojām darbojas pirmais funkcijas izsaukums, tiek izpildīts otrais, izveidojot divu tukšu šūnu sarakstu, pārbaudot ierobežotu stāvokli un pārbaudot visas tukšās šūnas. Otrais izsaukums pēc tam modificē newBoard, ievietojot huPlayer pirmajā tukšajā laukumā. Pēc tam tas izsauc sevi no newBoard un aiPlayer un gaida trešo zvanu, lai atgrieztu vērtību.
Tā kā otrajā izsaukumā tika atrastas divas tukšas šūnas, minimax modificē newBoard, ievietojot huPlayer otrajā tukšajā šūnā. Pēc tam tas izsauc sevi no newBoard un aiPlayer.
Algoritms sastāda tukšo šūnu sarakstu un reģistrē spēlētāja uzvaru pēc stāvokļa galīguma pārbaudes. Tātad tas atgriež objektu ar punktu lauku (-10).
Otrajā funkcijas izsaukumā algoritms saņem vērtības, ko no zemākā līmeņa atgriež trešais un ceturtais funkcijas izsaukums. Tā kā huPlayer gājiens radīja šos divus rezultātus, algoritms izvēlas mazāko. Tā kā tie ir vienādi, algoritms izvēlas pirmo un nodod to pirmajam funkcijas izsaukumam.

Šajā brīdī pirmais funkcijas izsaukums saņēma aprēķinu par aiPlayer pārvietošanos uz pirmo tukšo šūnu. Pēc tam tas modificē newBoard, ievietojot aiPlayer otrajā tukšajā laukumā. Pēc tam tas sevi sauc no newBoard un huPlayer.
Piektajā funkcijas izsaukumā algoritms sastāda tukšo šūnu sarakstu un reģistrē AI uzvaru pēc stāvokļa galīguma pārbaudes. Tātad tas atgriež objektu ar punktu lauku +10.
Pēc tam pirmais zvans modificē newBoard, ievietojot aiPlayer trešajā tukšajā šūnā. Pēc tam tas sevi sauc no newBoard un huPlayer.
Sestais izsaukums izveido sarakstu ar divām tukšām šūnām, pārbauda stāvokļa galīgumu un veic visas tukšās šūnas. Pēc tam tas modificē newBoard, ievietojot huPlayer pirmajā tukšajā laukumā. Pēc tam tas izsauc sevi no newBoard un aiPlayer un gaida septīto zvanu, lai atgrieztu vērtību.
Jaunais izsaukums izveido vienas tukšas šūnas sarakstu, pārbauda ierobežotu stāvokli un modificē newBoard, lai ievietotu aiPlayer tukšajā šūnā. Pēc tam tas izsauc sevi no newBoard un huPlayer un gaida, līdz šis zvans atgriezīs vērtību.
Astotais izaicinājums ir tukšs saraksts tukšas šūnas un ieraksta aiPlayer uzvaru pēc ekstremitāšu stāvokļa pārbaudes. Tāpēc tas atgriež objektu ar skaitīšanas lauku, kas vienāds ar (+10), augstākajā līmenī, septītajā izsaukumā.
Septītais zvans saņēma tikai vienu pozitīvu vērtību no zemākajiem līmeņiem. Tā kā šī vērtība tika iegūta aiPlayer gājiena laikā, algoritms atgriež lielāko iegūto vērtību. Tātad tas atgriež pozitīvu vērtību (+10) līdz līmenim uz augšu, sestais zvans.

Tā kā sestajā izsaukumā tika atrastas divas tukšas šūnas, minimax modificē newBoard, ievietojot huPlayer otrajā tukšajā šūnā. Pēc tam tas izsauc sevi no newBoard un aiPlayer.
Pēc tam algoritms sastāda tukšo šūnu sarakstu un pēc stāvokļa galīguma pārbaudes reģistrē aiPlayer uzvaru. Tāpēc tas atgriež objektu ar punktu lauku, kas vienāds ar (+10), augstākajā līmenī.
Šajā brīdī sestajam izaicinājumam ir jāizvēlas starp rezultātu (+10), ko atdeva septītais izaicinājums, un rezultātu (-10), ko atdeva devītais izaicinājums. Tā kā huPlayer gājiens radīja šos divus rezultātus, algoritms atlasa mazāko un atgriež to nākamajā līmenī kā objektu ar rezultātu un indeksa laukiem.

Visbeidzot, tiek novērtēti visi trīs pirmā izsaukuma atzari (-10, +10, -10). Tā kā aiPlayer gājiens radīja šos trīs rezultātus, algoritms atlasa objektu, kurā ir vislielākais punktu skaits (+10) un tā indekss (4).

Iepriekš minētajā scenārijā minimax to izlemj optimāla izvēle būs pārcelšanās uz laukuma centrālo laukumu.

Beigas!

Tagad jums vajadzētu saprast, kā darbojas minimax algoritms. Mēģiniet pats uzrakstīt implementāciju vai skatiet piemēru vietnē GitHub vai CodePen un optimizējiet to.

Ja jūs interesē AI tēma spēlēs, iesakām izlasīt mūsu materiālus par šo tēmu.

1. SOLIS. FORMAS PARAMETRU KONFIGURĒŠANA1. Lai pielāgotu veidlapu, iestatiet tās izmēru
510 punkti horizontāli un 480 punkti horizontāli
vertikāli. Maksimums un minimums
norādiet izmēru, kas vienāds ar tām pašām vērtībām.
2. Nosauciet formu “Tic Tac Toe”.
3. Veidlapas fonam izmantojiet failu no mapes
Attēli zem nosaukuma background.png un ievietojiet to
veidlapas centrā.
4. Ikonai virsraksta rindā
izmantojiet lietotnes failu no mapes
Attēli zem nosaukuma menu4.ico.
5. Jāiestata veidlapas fona krāsa
Piparmētru krēms.

2. SOLIS. POGAS UN ETIĶES PIEVIENOŠANA VEIDLAPA

1. Izvietotiem elementiem mainiet
fonta lielums līdz 12 un iestatīts fons
caurspīdīgs.

1. Izveidojiet izvēlņu joslu ar vienumiem
kā parādīts attēlā.

3. SOLIS. IZVĒLNES JOSLAS PIEVIENOŠANA VEIDLAPA

1. Izvēlnes vienumā Fails izveidojiet komandu
Izeja.
2. Par
komandas
Izeja
izrakstīsim
programmas kods ir tāds pats kā programmā
iepriekšējais pieteikums.

3. SOLIS. IZVĒLNES JOSLAS PIEVIENOŠANA VEIDLAPA

1. Izvēlnes vienumā Spēle izveido komandu
Jauna spēle.
2. Komandai Jauna spēle mēs rakstīsim
programmas kods nākotnē, izmantojot
dažus soļus.

3. SOLIS. IZVĒLNES JOSLAS PIEVIENOŠANA VEIDLAPA

1. Palīdzības izvēlnes vienumā izveidojiet komandu
Par programmu.
2. Komandai Par programmu izveidojiet jaunu
veidojiet un uzrakstiet programmas kodu
līdzīgi kā iepriekšējā
pieteikumu.

1. Velkot PictureBox objektu uz formu
mainiet tā izmēru uz 100x100.
2. Iestatiet caurspīdīgu fonu.
3. Novietojiet PictureBox, kā parādīts attēlā
attēls virs spēles lauka pirmās šūnas.

4. SOLIS. PICTUREBOX OBJEKTU PIEVIENOŠANA VEIDLAPA

1
2
3
4
5
6
7
8
9
1. Virs atlikušajām šūnām mēs novietojam
PictureBox objekti, pirmās kopijas
objekts, saskaņā ar norādīto numerāciju
Attēli.

1. Pirms koda rakstīšanas
nepieciešams mapē
\Visual Studio
2010\Projects\Tic Tac Toe\X's
nulles\bin\Debug\ ir atkārtoti jārullē
faili x.png, 0.png, none.png no mapes Attēli.
2. Veiciet dubultklikšķi ar peles kreiso taustiņu uz pirmā
PictureBox.

5. SOLIS. KODA PIEVIENOŠANA PICTUREBOX OBJEKTIEM

1. Izveidojiet divdimensiju masīvu, kas ir pieejams visiem elementiem
izveidots 3x3 elementu veidā, kas sastāv no veseliem skaitļiem. Tūlīt
deklarējot to aizpildām ar nullēm. Par tukšām šūnām mēs
Mēs izmantosim 0, “krustiem” - 1, un “nulles” - -1.

5. SOLIS. KODA PIEVIENOŠANA PICTUREBOX OBJEKTIEM

Procedūrā, kad noklikšķināt uz pirmā
PictureBox, pievienojiet operatoru
izvēle
kuras
gribu
pārbaudīt statusu
masīva šūnas. Ja vērtība
masīva šūnas būs vienādas ar 0, kas
tas nozīmē, ka nav ne “nulles”, ne
“krusts”, tad šajā šūnā
masīvs ir rakstīts 1 un in
Picture Box1
parādīts
“krusta” attēls un ja
masīva šūnas vērtība būs
ir vienāds ar 1, tad tas satur
Tajā ir ierakstīts “krusts” un 0, un
Tiek parādīta tukša šūna.

5. SOLIS. KODA PIEVIENOŠANA PICTUREBOX OBJEKTIEM

1
2
3
4
5
6
7
8
9

Pārējām lauka šūnām pievienojiet kodu
tāds pats kā pirmajā, tikai mainās
PictureBox objekta numurs un šūnas adrese
masīvs.
PIEMĒRS otrajai šūnai:

Procedūrā, kad noklikšķināt uz pogas
pievienot
operators
cikls
kurš pārbauda
visas šūnas, sākot no pirmās līdz
tukšu šūnu klātbūtne. Un ja
šūna ir tukša,
tad viņā
“nulle” ir rakstīts, proti, in
masīva šūna ir uzrakstīta -1.
Ērtībai turpmākajā darbā
mainīgie
es,
j
kuras
izmanto cilpu atkārtošanai
Mēs paziņosim par visu formu.

6. SOLIS. KODA PIEVIENOŠANA STAIGĀM POGAI

Lai parādītu nulles
spēles
lauks
nepieciešams
pievienojiet programmas kodu pamattekstam
cikls, kurā pārbauda šūnu tukšumu.
Izmantojot ligzdotu paziņojumu
zarošanās
gribu
norisināties
masīva šūnu adreses analīze
pareizi ievadiet nulli
PictureBox.
Mēs arī pievienojam pārtraukuma paziņojumu
priekšlaicīgai beigām
cilpa, atrodot tukšu
šūnas.

6. SOLIS. KODA PIEVIENOŠANA STAIGĀM POGAI

Lai norādītu spēles statusu
tiek izmantots interfeisa elements
Etiķete1. Tā kā spēlētājs vienmēr kustas
vispirms
Tas
plkst
lejupielādes
lietojumprogrammas
nepieciešams
V
elements
Etiķete1
nepieciešams
atspoguļot
frāzes “Jūsu
kustēties."
Priekš
šis
veidosim
mainīgs
atbildi
kuras
Piešķirsim šo frāzi. A
ielādējot formu mainīgo
ir jāpiešķir elementam
Label1, lai izveidotu nepieciešamo
procedūras
nepieciešams
vispirms veiciet dubultklikšķi
pēc formas

7. SOLIS. PROGRAMMAS KODA PIEVIENOŠANA JAUNĀ SPĒLES IZVĒLNES POZĪCIJAI

Nospiežot komandu new
spēle tiks atiestatīta
visas masīva šūnas, aizstājot visas
"krusti" un "pirksti" uz
tukšas šūnas. Arī secinājums
Zīmes "Tavs gājiens".

8. SOLIS. IZvadiet SPĒLES REZULTĀTU

Lai pārbaudītu kustību rezultātus
nepieciešams
analizēt
rindu, kolonnu saturs un
diagonāles. Ja visi trīs elementi
ir vienādi ar 1, tad šī ir spēlētāja uzvara, un
ja trīs -1, tad šī ir sakāve
spēlētājs.
Nepieciešama uzvaras pārbaude
rīcību
pirms tam
progresu
dators,
A
pārbaudiet
sakāve pēc.
Procedūras pēdējā komanda
rezultāti tiks parādīti ekrānā
progresu.

8. SOLIS. IZvadiet SPĒLES REZULTĀTU

Programmas kods, lai pārbaudītu lietotāja uzvaru:
if (znacheniyeYacheyki == 1 && znacheniyeYacheyki == 1 && znacheniyeYacheyki == 1) otvet = "Tu uzvarēsi";
if (znacheniyeYacheyki == 1 && znacheniyeYacheyki == 1 && znacheniyeYacheyki == 1) otvet = "Tu uzvarēsi";
if (znacheniyeYacheyki == 1 && znacheniyeYacheyki == 1 && znacheniyeYacheyki == 1) otvet = "Tu uzvarēsi";
if (znacheniyeYacheyki == 1 && znacheniyeYacheyki == 1 && znacheniyeYacheyki == 1) otvet = "Tu uzvarēsi";
if (znacheniyeYacheyki == 1 && znacheniyeYacheyki == 1 && znacheniyeYacheyki == 1) otvet = "Tu uzvarēsi";
if (znacheniyeYacheyki == 1 && znacheniyeYacheyki == 1 && znacheniyeYacheyki == 1) otvet = "Tu uzvarēsi";
if (znacheniyeYacheyki == 1 && znacheniyeYacheyki == 1 && znacheniyeYacheyki == 1) otvet = "Tu uzvarēsi";
if (znacheniyeYacheyki == 1 && znacheniyeYacheyki == 1 && znacheniyeYacheyki == 1) otvet = "Tu uzvarēsi";
Programmas kods, lai pārbaudītu lietotāja uzvaru:
if (znacheniyeYacheyki == -1 & znacheniyeYacheyki == -1 & znacheniyeYacheyki == -1) otvet = "Jūs zaudējāt";
if (znacheniyeYacheyki == -1 & znacheniyeYacheyki == -1 & znacheniyeYacheyki == -1) otvet = "Jūs zaudējāt";
if (znacheniyeYacheyki == -1 & znacheniyeYacheyki == -1 & znacheniyeYacheyki == -1) otvet = "Jūs zaudējāt";
if (znacheniyeYacheyki == -1 & znacheniyeYacheyki == -1 & znacheniyeYacheyki == -1) otvet = "Jūs zaudējāt";
if (znacheniyeYacheyki == -1 & znacheniyeYacheyki == -1 & znacheniyeYacheyki == -1) otvet = "Jūs zaudējāt";
if (znacheniyeYacheyki == -1 & znacheniyeYacheyki == -1 & znacheniyeYacheyki == -1) otvet = "Jūs zaudējāt";
etiķete1.Teksts = atbilde;

9. SOLIS ATSKAŅAMĪBAS UZLABOŠANA

Lai uzlabotu spēlējamību
sērijas izejas vietā
uz pirmajiem tukšajiem
“nulles” šūnas, mēs ieviešam
izvade caur nejaušības ģeneratoru
cipariem.
Lai to izdarītu, jums jāpievieno
viens loģiskais mainīgais
uslovie un mainiet cilpas veidu no For
uz Kamēr, jo mēs nezinām
precīzs atkārtojumu skaits
ģenerators nejauši skaitļi Uz redzēšanos
tas neiekritīs tukšā šūnā.

KRIEVIJAS IZGLĪTĪBAS UN ZINĀTNES MINISTRIJA

federālā valsts budžeta augstākās profesionālās izglītības iestāde

"Vologdas Valsts universitāte"

Automatizācijas un datortehnikas katedra

Paskaidrojuma raksts kursa projektam disciplīnā

Programmēšanas un algoritmu pamati

"Desas spēle"

Pabeigts EM-21 grupas audzēknis

Butorova L.Ju.

Pieņemts Ržeutskaja S. Ju.

IEVADS

1. PROBLĒMAS ANALĪZE UN PRASĪBU NOTEIKŠANA IZSTRĀDĀTAJAI PROGRAMMAI

1 Programmas mērķis, tās lietotāji, galvenās funkcijas un izstrādes laikā izvirzītie mērķi

2 Pārskats par labi zināmām programmām, kas veic līdzīgas funkcijas

3 Attīstības teorētiskā bāze

4 Izstrādes rīku izvēle

DIZAINS IZSTRĀDES DAĻA

1 Lietotāja saskarnes izstrāde

2.2 Datu struktūru izstrāde (ārējā un RAM)

2.3. Algoritmu izstrāde un analīze

PROGRAMMAS ĪSTENOŠANA C++ VALODĀ

1 Programmas arhitektūra

2 Standarta vizuālo un nevizuālo komponentu izvēle

TESTA REZULTĀTI

SECINĀJUMS

Bibliogrāfija

Lietojumprogrammas

IEVADS

Tic-tac-toe ir loģiska spēle starp diviem pretiniekiem uz kvadrātveida laukuma, kurā ir 3 x 3 šūnas vai lielāka (līdz “bezgalīgam laukam”). Viens no spēlētājiem spēlē ar "krustiņiem", otrs - ar "pirkstiem". Šī spēle kļuva populāra ilgi pirms datoru parādīšanās, tikai pirms to spēlēja ar parastu papīru un pildspalvu. Tradicionālajā ķīniešu spēlē tiek izmantoti melni un balti akmeņi.

Šajā kursa darbs Tiek saglabāti spēles laukuma pamatnoteikumi un standarta izmērs (3x3 šūnas). Spēles ērtībai tiesības veikt pirmo gājienu tiek atstātas lietotājam, tas ir, “krusti”.

Tic Tac Toe ir programma, kas paredzēta lietotāja izklaidēšanai, tāpēc tās interfeiss šajā kursa darbā ir veidots spēles stilā ar pozitīvu krāsu kombināciju, kas pastiprina spēles procesa emocionālo daļu.

Spēlē ir trīs veidi: X pret 0 - lietotājs pret lietotāju, "1. līmenis ar datoru" - tiem, kas tikai apgūst pasaules spēles pamatus, un līmenis "2. līmenis ar datoru" - tiem, kuri ir pilnīgi pārliecināti par savu uzvaru. 1. un 2. līmenī ir trīs iespējamie iznākumi: “uzvara”, “zaudēts” un “neizšķirts”. Laimests tiek fiksēts, ja vertikālās, horizontālās vai diagonālās līnijas ir pilnībā aizpildītas ar krustiņiem vai nullēm.

Ja laukuma brīvās šūnas ir beigušās, bet neviens neuzvar, tad tiek uzskatīts, ka spēle beidzas ar “neizšķirtu”.

1. PROBLĒMAS ANALĪZE UN PRASĪBU NOTEIKŠANA IZSTRĀDĀTAJAI PROGRAMMAI

programmas krusteniskā saskarne

1.1. Programmas mērķis, tās lietotāji, galvenās funkcijas un izstrādes gaitā izvirzītie mērķi

Šīs programmas mērķis, pirmkārt, ir izklaidēt lietotājus, paspilgtināt cilvēka gaidīšanas laiku, jo jebkurš darbs prasa atpūtu, un šī vienkāršā spēle palīdzēs atpūsties un novērst domas no ikdienas lietām. “Tic Tac Toe” pieder arī intelektuālo un loģisko spēļu klasei, kas paredzētas loģiskās domāšanas trenēšanai, ļauj koncentrēt uzmanību un attīstīt atmiņu.

Lietotāju mērķauditorija ir bērni un pusaudži, kā arī pieaugušie. Galvenie produkta lietošanas kritēriji ir spēja lasīt programmā rakstītu tekstu un iespēja izvēlēties datoram nepieciešamo uzdevumu, izmantojot pogas.

No tā mēs varam secināt, ka galvenie uzdevumi ir: izklaides uzdevums un uzdevums attīstīt cilvēka loģisko potenciālu.

1.2. Pārskats par labi zināmām programmām, kas veic līdzīgas funkcijas

Internetā var atrast lielu skaitu darbu, kas īsteno šo spēli. Pašlaik ir daudz šīs spēles analogu, kas ir atkāpušies no sākotnējiem standartiem. Šādu programmu piemēri ir “Tic-tac-toe uz nebeidzamā lauka” un “Tic-tac-toe 3D”. Tāpat daudzās spēlēs “krusti” un “pirksti” tiek aizstāti ar citiem simboliem, piemēram, “akmeņiem”.

Mans kursa projekts ir datora lietojumprogramma. Spēle paredzēta gan vienam lietotājam, kura pretinieks ir mākslīgais intelekts (vai dators), gan diviem lietotājiem. Tas tiek prezentēts klasiskā 3x3 laukā.

Interesantākā un neparastākā, manuprāt, bija spēle “Tic Tac Toe 3D”. Tāpēc es to izvēlējos salīdzināšanai.

3D tic-tac-toe ir daudz interesantāks nekā uz papīra vai uz parasta tāfeles. Ir vairāk iespēju uzvarēt un zaudēt, un neizšķirti notiek retāk. Jūs varat spēlēt vienatnē - pret datoru - vai kopā ar draugu. Un visneparastākais šeit ir tas, ka, lai uzvarētu, jūs varat izveidot trīs savas krāsas bumbiņas (melnas vai baltas) ne tikai vienā līmenī, bet arī gar sienu plakni un pat pa diagonāli visā laukā ( 1.1. att.).

Rīsi. 1.1

Starp daudzveidīgajām spēlēm par līdzīgu tēmu katrā darbā varam izcelt unikālu plāna realizāciju. Katrs projekts atšķiras no citiem ar savu individualitāti.

1.3. Attīstības teorētiskā bāze

Analīze

Katrai no pusēm ir labi zināmi algoritmi, kas garantē neizšķirtu jebkurā pretinieka spēlē, un, ja pretinieks kļūdās, tas ļauj viņam uzvarēt. Tātad spēle ir stāvoklī "neviena nāve"<#"877528.files/image002.gif">

1.2.att. Spēles situāciju koks

Daļējs spēles situāciju koks ir parādīts 1.2. attēlā spēlei tic-tac-toe. Spēles situāciju koks spēlei tic-tac-toe, kur “krustu” spēlētājs iet pirmais un rīkojas saskaņā ar iepriekš minēto algoritmu, bet “pirkstu” spēlētājs var darīt visu, ko vēlas (un viena virsotne ir dots racionālai un neracionālai darbībai, tas ir, jebkurai citai), sastāv no 50 mezgliem.

1.4. Izstrādes rīku izvēle

Lai sasniegtu savus mērķus, mums ir nepieciešama integrēta lietojumprogrammu izstrādes vide. Tāpēc projekta izstrāde tika veikta Microsoft Visual Studio 2008 programmēšanas vidē.

Microsoft Visual Studio ir Microsoft produktu līnija , tostarp integrēta izstrādes vide programmatūra un vairāki citi rīki. Šie produkti ļauj izstrādāt konsoles lietojumprogrammas un GUI lietojumprogrammas , tostarp atbalsts Windows Forms tehnoloģijai , kā arī tīmekļa vietnes , tīmekļa pakalpojumi kā dzimtajā , un kontrolēts kodi visām platformām, kuras atbalsta sistēma Windows , Windows Mobile , Windows CE , .NET Framework , Xbox , Windows Phone .NET Compact Framework un Silverlight .

2. IZSTRĀDES DIZAINĒŠANAS DAĻA

2.1. Lietotāja saskarnes izstrāde

Veidojot spēļu aplikāciju, ir jāņem vērā viena no galvenajām produkta veiksmes sastāvdaļām – interfeiss. Programmas lietotāja saskarnei, pirmkārt, ir jābūt lietotājam saprotamam un pievilcīgam. Jums jācenšas noņemt visus momentus, kas novērsīs lietotāja uzmanību vai radīs viņam diskomfortu. Visu programmas interfeisu var iedalīt divās daļās.

) Programmas galvenā izvēlne

Rīsi. 2.1 - Programmas galvenā izvēlne

Galvenā izvēlne ir veidota tā, lai lietotājs varētu pievienoties spēļu atmosfērai, tāpēc interfeiss ir veidots krāsainās, rotaļīgās krāsās. Izmantojot izvēlni, varat doties uz spēles laukumu, apskatīt spēles noteikumus vai iziet no spēles.

) Spēles laukums

2.2. att. — spēles laukums

Spēles laukums satur tūlītēju spēles laukumu, kurā spēlētājs un dators novieto savas ikonas. Pirms spēles sākšanas lietotājam ir jāizvēlas spēles veids, piemēram, "X pret 0", "1 līmenis ar datoru" vai "2 līmenis ar datoru", pretējā gadījumā programma dos ziņojumu par to, ko darīt. Poga, kas palīdzēs spēlētājam atgriezties galvenajā izvēlnē. Beigās parādīsies papildu logi, lai informētu dalībnieku par spēles rezultātiem.

Rīsi. 2.3 - papildu spēļu rezultātu logi

2.2 Datu struktūru izstrāde (ārējā un RAM)

RAM tiek izmantots viendimensionālam masīvam, kas sastāv no 9 elementiem, kas glabā spēles lauka stāvokļus, kur katra masīva šūna atbilst šūnai spēles laukā. Atmiņa tiek tērēta arī statiskajiem mainīgajiem: līmeņa numurs, pagriezienu secība.

Lai tā darbotos, ir nepieciešami 803 KB brīvas atmiņas.

.3 Algoritmu izstrāde un analīze

Lai ieviestu spēles domāšanas algoritmu, jāiestata statisks masīvs gcnew masīvs (9); kurā tiks saglabāti spēles lauka stāvokļi, kur katra masīva šūna atbilst šūnai. “0” - atbilst tukšai šūnai, ja spēlētājs ir pārcēlies šūnā, tas ir, “X”, tiek ierakstīta vērtība “1” un, ja dators veica gājienu, tas ir, “O”, vērtība ir "2". Sākotnēji visi masīva elementi ir vienādi ar "0". Nepieciešams iestatīt statisko mainīgo lvl, kas glabā līmeņa datus. Šajā spēlē kopumā ir 3 līmeņi: lvl iegūst vērtību “1”, ja lietotājs ir izvēlējies spēles veidu “X pret O”, vērtību “2”, ja “1. līmenis ar datoru”, un vērtību “3”. " ja "2. līmenis ar datoru" " Spēlētāja mainīgais saglabā gājiena secību (“true” ir spēlētāja gājiens, “false” ir datora gājiens). Tā kā tiesības veikt pirmo gājienu tiek dotas lietotājam, tad spēles sākumā spēlētājs = true. Karoga statiskais mainīgais saglabā informāciju par to, vai spēles laukā ir tukšas šūnas vai nav: ja karogs = true - tas ir, false - tukšu šūnu nav. Pārbaudes algoritmam jāietver masīva x parametru iterācija un jāizvirza savs risinājums, kas būs optimāls turpmākai atskaņošanai. Šī programma piedāvā 2 līmeņus spēlēšanai ar datoru. 1. līmenī datora uzdevums nav pārspēt pretinieku. Tāpēc šī funkcija atgriež nejaušu tās šūnas vērtību, uz kuru tiks novirzīts dators. Šī algoritma kods ir parādīts [1. pielikumā]. 2.4. attēlā parādīta koda ieviešanas blokshēma.

Uzvarošākais gājiens spēles sākumā ir pāriet uz laukuma centru. Funkcijā dif_level() sākumā tiek pārbaudīts nosacījums: ja spēlētājs negāja uz centrālo lauku, tad dators iet uz turieni. Citādi, ja spēlētājs devās uz centru, tad tiek izsaukta funkcija check(2), lai pārbaudītu datora kombināciju un, ja ir iespēja laimēt, tad atgrieztu šūnas numuru. Ja dators nevar uzvarēt nākamajā gājienā, tad tiek izsaukta pārbaude (1) funkcija: spēlētāja kombinācijas pārbaude. Tās šūnas numurs, kurā spēlētājs būtu laimējis, ja likme tiktu atgriezta. Ja šādas kombinācijas nav, tad tiek izsaukta funkcija low_level().

2.4.att. - Blokshēma

2.5.att. - Blokshēma

3. PROGRAMMAS ĪSTENOŠANA C++ VALODĀ

.1 Programmas arhitektūra

Šī programma realizē 3 formas: galvenā izvēlne (2.1. att.), spēles laukums (2.2. att.) un palīdzības lauks (spēles noteikumi); 12 paneļi, no kuriem 9 ir galvenie. Tāpat spēles beigās parādās pictureBox ar rezultātu, kopā ir 5 (2.3. attēls).

Par pamatu varat izmantot paneļa klikšķu apstrādātājus, no kuriem spēles laukumā ir tieši 9. Katrs apdarinātājs izsauc vairākas funkcijas. Sākumā ir nosacījums, ja lietotājs izvēlas spēles veidu “X pret 0”, šūnas tiek vienkārši aizpildītas ar vērtībām 1 vai 2 (krusts vai nulle). Tālāk seko funkcijas: progresa indikācija (CrossZero()), kas maina krustiņu uz nulli un otrādi, aizņemto šūnu bloķēšana checkingArray(), uzvarētāja atrašana(). Funkcija uzvarētājs() ņem vērā visas iespējamās laimēšanas iespējas, tāpēc, ja kāds no spēlētājiem sakārtos 3 savas figūras (krustiņu vai nulli) vertikāli, horizontāli vai pa diagonāli, viņš uzvarēs. Pretējā gadījumā, ja laukums ir pilns, bet neviens no spēlētājiem nav ierindojies, tad tiek izsaukta (_draugs()) neizšķirtu pārbaudes funkcija, kas pārbauda, vai laukumā ir palikušas brīvas šūnas vai nav. Ja fr = patiess, tad laukā nav brīvu šūnu. Ja vērtība ir mainījusies, tas nozīmē, ka laukā ir brīva šūna.

Otrais nosacījums darbojas, ja ir izvēlēts otrais vai trešais spēles veids. Tad funkcija, kurā tika veikta datora kustība, tiek izsaukta: move(int n). Tas pārraida tās šūnas numuru, uz kuras spēlētājs noklikšķināja. Tālāk nāk funkcijas: progresa indikācija (CrossZero()), aizņemto šūnu bloķēšana checkingArray(). Pēc tam tiek izsaukta funkcija uzvarētājs(), kas pārbauda, vai spēlētājs uzvarēja ar šo gājienu vai nē. Ja nē, tad tiek pārbaudīta brīvo šūnu klātbūtne. Ja ir brīvas šūnas, tad dators kustas. Tālāk, atkarībā no tā, kādu līmeni atskaņotājs “1” vai “2” ir izvēlējies, tiek izsauktas šādas funkcijas: low_level(), dif_level(). Funkcija low_level() nejauši izvēlas, kur novietot nulli, un funkcija dif_level() piedāvā īpašu algoritmu, lai dators varētu uzvarēt. Tālāk nāk funkcijas: progresa indikācija (CrossZero()), aizņemto šūnu bloķēšana checkingArray(). Pēc tam tiek izsaukta funkcija uzvarētājs(), kas pārbauda, vai dators uzvarēja ar šo gājienu vai nē. Ja nē, tad tiek pārbaudīta brīvo šūnu klātbūtne. Ja ir brīvas šūnas, tad spēlētājs pārvietojas.

.2 Standarta vizuālo un nevizuālo komponentu izvēle

Lai īstenotu šo darbu, tika atlasīti šādi komponenti:

1) Form1, ar dotie parametri Text=Tic-Tac-Toe, ControlBox=False

2) f2, ar norādītajiem parametriem BackColor, Text=Game

) comboBox1 ar norādītajiem vienumu parametriem:

X pret 0

1.līmenis ar datoru

2. līmenis ar datoru

4) panelis ar norādītajiem BackColor parametriem un dažādām vērtībām parametriem Visible un Enabled. Dažiem paneļiem tika rakstīti tādi notikumi kā Click.

5) poga, ar norādītajiem parametriem Fonts, Fore Color, BackColor, Text, visām pogām tika ierakstīti tādi notikumi kā Click.

6) etiķete, ar norādītajiem parametriem BackColor, Font, Fore Color, Text.

) pictureBox, ar norādītajiem parametriem Image, SizeMode= StretchImage.

) textBox, ar norādītajiem parametriem BackColor, Font, Fore Color, Text=” ”.

4. TESTA REZULTĀTI

Pārbaudīsim programmu, izejot cauri 3 veidu spēlēm.

Izmēģināsim galvenās izvēlnes pogu darbības. Pogas darbojas pareizi. Mēģināsim sākt spēli, neizvēloties spēles veidu. Programma parāda kļūdas ziņojumu un lūdz izvēlēties spēles veidu.(4.1.att.)

4.1.att.

Izvēlēsimies 1 spēles veidu - “X pret 0”, t.i. lietotājs pret lietotāju. Šajā spēles posmā lietotājs var spēlēties arī ar sevi. (4.2. att.)

4.2.att.

Spēles “Līmenis 1 ar datoru” laikā dators neizvirza sev mērķi uzvarēt dalībnieku. Viņš vienkārši ieliek nulles brīvas vietas lauki. Šajā posmā lietotājs var viegli pārspēt datoru. Lai gan šajā līmenī iespējami arī citi notikumu attīstības varianti.

Att.4.3.

Spēles veids: “2. līmenis ar datoru”. Šajā posmā spēle analizē visas kustības un mēģina izvēlēties optimālāko gājienu. Arī šeit ir iespējami visi trīs scenāriji, jo Dators pirmo reizi pārvietojas uz jebkuru brīvu šūnu. Visbiežāk spēle noslēdzas līdz neizšķirtam.

Att.4.4.

Programma veiksmīgi darbojas visos testa variantos, bez kļūdām.

SECINĀJUMS

Ar pārliecību varam teikt, ka darba sākumā izvirzītais uzdevums ir izpildīts. Izstrādes laikā tika plānots un izstrādāts slavenās spēles “Tic Tac Toe” remiksa projekts. Spēle atbilst noteiktajām prasībām un pilda savas funkcijas. Īstenots darbā Dažādi veidi spēles un grūtības līmeņi.

Darba gaitā tika apgūtas jaunas programmēšanas metodes integrētā izstrādes vidē. Ir nostiprinātas vecās zināšanas darbā ar C++ valodu. Gatavojoties kursa darbam, tika analizētas dažādas metodes un algoritmi šīs spēles realizācijai.

Neskatoties uz šīs programmas šķietamo vienkāršību, tā ir saistīta ar vairākām grūtībām, kas tiek īstenotas, izmantojot visas Visual C++ pamatmetodes.

Šīs programmas funkcijas ir:

Skaidri izveidots algoritms;

Intuitīvs interfeiss;

Viegli izmantot;

Diezgan skaidra lietotāja rokasgrāmata;

Nav nevajadzīgu papildinājumu.

BIBLIOGRĀFIJA

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

1. PIELIKUMS

private: int low_level())(// procedūra vieglam pretiniekam;::Random^ rand = gcnew System::Random();(= rand->Next(0,8);

) while (x[r] != 0);r;

2. PIELIKUMS

privāts: bool check(int n)(k = -1;// pārbauda visas kombinācijas un atgriež pareizo gājienu(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) return true;else return false;

3. PIELIKUMS

privāts: int dif_level())(//grūts ienaidnieks

//atgriezties pārbaude(2);(x == 0) return (4);(pārbaude(2)) atgriezties k; else (pārbaude(1)) return k; cits zems_līmenis();

PIETEIKUMS 4

privāts: void CrossZero())(// maina krustiņu uz nulli (progresa indikators)(player) (->Redzams = patiess;->Redzams = false;

) else (->Redzams = patiess;->Redzams = nepatiess;

): void checkingArray())(// funkcija, kas pārbauda, vai šūnā ir kaut kas, ja ir, tad vairs nevar noklikšķināt uz šīs šūnas.(x == 1) (panelis1->BackgroundImage = panel11->BackgroundImage ;panelis1- >Iespējots = false;)(x == 2) (panelis1->BackgroundImage = panelis10->BackgroundImage;panel1->Enabled = false;)(x == 1) (panelis2->BackgroundImage = panelis11->BackgroundImage ;panel2- >Iespējots = false;)(x == 2) (panelis2->BackgroundImage = panelis10->BackgroundImage;panel2->Enabled = false;)(x == 1) (panelis3->BackgroundImage = panelis11->BackgroundImage ;panelis3- >Iespējots = false;)(x == 2) (panelis3->BackgroundImage = panelis10->BackgroundImage;panel3->Enabled = false;)(x == 1) (panelis4->BackgroundImage = panelis11->BackgroundImage ;panel4- >Iespējots = false;)(x == 2) (panelis4->BackgroundImage = panelis10->BackgroundImage;panel4->Enabled = false;)(x == 1) (panelis5->BackgroundImage = panelis11->BackgroundImage ;panel5- >Iespējots = false;)(x == 2) (panelis5->BackgroundImage = panelis10->BackgroundImage;panel5->Enabled = false;)(x == 1) (panelis6->BackgroundImage = panelis11->BackgroundImage ;panel6- >Iespējots = false;)(x == 2) (panelis6->BackgroundImage = panelis10->BackgroundImage;panel6->Enabled = false;)(x == 1) (panelis7->BackgroundImage = panelis11->BackgroundImage ;panel7- >Iespējots = false;)(x == 2) (panelis7->BackgroundImage = panelis10->BackgroundImage;panel7->Enabled = false;)(x == 1) (panelis8->BackgroundImage = panelis11->BackgroundImage ;panel8- >Iespējots = false;)(x == 2) (panelis8->BackgroundImage = panelis10->BackgroundImage;panel8->Iespējots = false;)(x == 1) (panelis9->BackgroundImage = panelis11->BackgroundImage ;panel9- >Iespējots = false;)(x == 2) (panelis9->BackgroundImage = panelis10->BackgroundImage;panel9->Iespējots = false;)

): bool uzvarētājs())(// uzvarētāja pārbaude un visu atlikušo šūnu bloķēšana.

//pamatots karogs = false;(((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) ( picturePo->Redzams = patiess;)(picturePr->Redzams = patiess;)->Iespējots = false;->Iespējots = false;->Iespējots = nepatiess;->Iespējots = nepatiess;-> Enabled = false;->Enabled = false;->Enabled = false;->Enabled = false;->Enabled = false;true;

)(((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) (picturePx->Redzams = patiess;)(picturePobeda->Redzams = patiess;)->Iespējots = false;->Iespējots = false;->Iespējots = nepatiess;->Iespējots = nepatiess;->Iespējots = nepatiess;-> Enabled = false;->Enabled = false;->Enabled = false;->Enabled = false;true;

): spēkā neesošs _draugs())(fr = patiess;(int i = 0; i< 9; i++) if (x[i] == 0) {fr = false; break;}(fr) { pictureN->Redzams = patiess ;)

): spēkā neesošs gājiens(int n)(// datora pārvietošanas funkcija= false;[n] = 1;= !player;();();(uzvarētājs()) () ((int i = 0; i< 9; i++) if (x[i] == 0) flag = true;(flag){(lvl == 2) = 2; = 2;= !player;();();();

): System::Void button1_Click(Sistēma::Objekts^ sūtītājs, Sistēma::EventArgs^ e) (// jauna spēle>Redzams = false;>Redzams = nepatiess;>Redzams = nepatiess; >Redzams = nepatiess; >Redzams = false; = ComboBox1->Teksts;(typeGame == "")(::Show("Vispirms izvēlieties spēles veidu!");

) else ((typeGame == "X pret 0") lvl = 1;(typeGame == "1. līmenis ar datoru") lvl = 2;(typeGame == "2. līmenis ar datoru") lvl = 3;( ); = patiess;(int i = 0; i< 9; i++) x[i] = 0;->BackgroundImage = panelis12->BackgroundImage;->BackgroundImage = panelis12->BackgroundImage;->BackgroundImage = panelis12->BackgroundImage;->BackgroundImage = panel12->BackgroundImage;->BackgroundImage = panelis12->BackgroundImage = panelis12->maka BackgroundImage;->BackgroundImage = panelis12->BackgroundImage;->BackgroundImage = panelis12->BackgroundImage;->BackgroundImage = panelis12->BackgroundImage;->Enabled = true;->Enabled = true;->Enabled = true;->Enabled = true;->Enabled = patiess;->Iespējots = patiess;->Iespējots = patiess;->Iespējots = patiess;->Iespējots = patiess;->Iespējots = patiess;

): Sistēma::Vid panelis1_MouseClick(Sistēma::Objekts^ sūtītājs, Sistēma::Windows::Forms::MouseEventArgs^ e) (n = 0;(lvl == 1)((player)( = 1;

)= !spēlētājs;();();();

): Sistēma::Vid panelis2_MouseClick(Sistēma::Objekts^ sūtītājs, Sistēma::Windows::Forms::MouseEventArgs^ e) (n = 1;(lvl == 1)((player)( = 1;

)= !spēlētājs;();();();