domov › Namestitev in nastavitev › Ustvarjanje igre tic-tac-toe. Teoretične osnove razvoja

Ustvarjanje igre tic-tac-toe. Teoretične osnove razvoja

Lep pozdrav dragi prijatelji! V tej vadnici vam bom pokazal, kako lahko naredite brskalniško igro - tic-tac-toe, v javascriptu! Vsi veste, kaj je ta igra in kako jo igrati, vendar naj vas še enkrat spomnim:

Tic-tac-toe je logična igra med dvema igralcema na kvadratnem polju 3 krat 3 (po možnosti večjem). Eden igra s "križi", drugi pa s "tac-toes".

P.S. kot v vseh podobnih vajah za javascript, lahko na koncu članka prenesete izvorno datoteko in si ogledate rezultat dela na demo primeru!

Opis igre, ki se ustvarja

Oglejmo si značilnosti igre:

igra se začne takoj po nalaganju strani;
pravica do prvega gibanja je izbrana naključno (ali začnete hoditi ali računalnik);
znak, ki ga boste postavili, je izbran naključno (križec ali nič);
če igralec zmaga, so zmagovalni simboli (trak s križci ali ničlami) označeni z zeleno;
če igralec izgubi proti računalniku, je vrstica označena z rdečo;
nad poljem je vrstica z informacijami, kjer je prikazan rezultat (zmaga ali poraz).

Logike

Nisem prišel do zapletenih (univerzalnih) algoritmov za igralno polje 3 krat 3 celice, šel sem v drugo smer - surovo silo! (več o tem kasneje). Identificiral sem tri glavne zaporedne stopnje, na katerih temelji celotna logika:

1. stopnja: preverite - ali je igralec zmagal?

Na tej stopnji preverimo, ali so 3 celice (v isti vrstici) zapolnjene z enakimi simboli igralca (križci ali ničle). Tisti. ne glede na to, kakšna je ta poteza (tudi prva), vedno najprej preverimo, ali je igralec zmagal. Takole izgleda zmaga:

2. stopnja: preveri - ali lahko računalnik zmaga pri naslednji potezi?

Na tej stopnji iščemo linijo, kjer bi bili 2 celici zapolnjeni z računalnikom in ena prazna celica – torej poskušamo zmagati zaradi nepazljivosti igralca. Takole izgleda poraz (t.i. računalniška zmaga):

3. stopnja: ne dovolite nam zmagati!

Tu iščemo isto vrstico kot v drugi stopnji, le 2 celici morata biti napolnjeni z igralčevimi znaki igre, to pomeni, da na tej stopnji računalniku ne dovolimo, da izgubi s postavitvijo znaka v prazno celico. Vsaka od stopenj je neodvisna funkcija - to lahko vidite v spodnji kodi js.

Izvedba

Postavitev igralnega polja je zelo preprosta - glavni blok vsebuje vrstico informacij (razred - rezultat) in 9 blokov, ki so celice (razred - blok) HTML oznaka celic:

Ti si na vrsti!

Razred celice pomočnik je potreben za natančno identifikacijo želene celice na igralnem polju. Slogi CSS za igralno polje:

Krestiki_noliki( width: 306px; margin: 0 auto; ) .krestiki_noliki .block( width: 100px; height: 100px; border: 1px solid #ccc; cursor: pointer; float: left; text-align: center; font-size: 100px; višina vrstice: 94px; )

Zdaj pa si oglejmo celotno kodo JS, nato pa bom govoril o glavnih točkah:

$(document).ready(function()( var znak_user = "O"; var znak_comp = "X"; var rand_num = Math.round((Math.random() * (9 - 1) + 1)); če (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"]; //Določite igralčevo funkcijo zmage 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; } }); });

Najprej deklariramo spremenljivke: znak_user - v to spremenljivko shranimo znak, ki ga bo uporabnik igral (privzeto je tam shranjena ničla - to je angleška kabina "O"). znak_comp - v tej spremenljivki shranimo znak, ki ga bo predvajal računalnik (privzeto je tam shranjen križec - to je angleška kabina "x").

Logika je naslednja: če je naključno število večje od 3, potem računalnik igra z ničlami in on (računalnik) naredi prvo potezo.

To logiko lahko spremenite po svojih željah, lahko na primer ustvarite nekaj naključnih števil, da naredite več možnosti za to, kdo bo vsaj prvi in kateri znaki. exit_flag - ta zastavica (spremenljivka) je odgovorna za izhod iz funkcije, to je na primer, ko je računalnik že naredil svojo potezo in morate zapustiti funkcijo in prenesti potezo na igralca. win_user_array - ta niz shranjuje vse zmagovalne možnosti za polnjenje celic. Da bo jasno, si poglejmo to sliko:

Vsak element matrike je niz treh števk, kar je zmagovalna kombinacija, to je, če na primer izpolnite celice pod številkami 1, 2 in 3, bo prišla zmaga (ali poraz). Kot lahko vidite, je skupno 8 zmagovalnih možnosti, naša naloga je razvrstiti vse te možnosti. Sledijo 3 funkcije:

preveri_3_uporabnika();
preveri_2_komp();
preveri_2_uporabnika();

Namen teh funkcij je opisan (v treh korakih) v razdelku Logika (zgoraj). Te funkcije prikličete s klikom na katero koli celico polja. Parameter (znak) se posreduje vsaki od funkcij - to je znak igralca ali računalnika (križ ali ničla), na primer v funkciji, ki določa zmago igralca (check_3_user), posredujemo znak igralca, da bi našli 3 enake znake na isti liniji.

Po treh funkcijah (če računalnik še ni naredil poteze) računalnik zapolni eno od prostih celic. Tukaj lahko zakomplicirate igro, na primer tako, da če je osrednja celica prosta (celica številka 5), potem najprej stavite vanjo, če je zasedena, potem stavite v enega od prostih kotov (to so celice št. 1, 3, 7 in 9) in tako naprej - na splošno je tukaj odvisno od vas.

To je načeloma vse, kar je potrebno za ustvarjanje takšne igre.

Zdaj si lahko ogledate igro v demo različici in prenesete izvorno datoteko (samo 1 datoteka).

08.06.2018 - hvala za pozornost avtorju pisma: Patvakan Baghdasaryan, napaka je bila odpravljena, ko je imel računalnik več opcije zmage in vse njegove zmagovite poteze so bile prebarvane (od 4 do 6 celic, namesto 3).

To je vse zame, upam, da je bila ta vadnica koristna za vas, želim vam veliko sreče, adijo!

Kako napisati bota, ki ga ni mogoče premagati v tic-tac-toe, ali Uvod v pravilo minimax

Možno je, da ste se po stotinah iger tic-tac-toe spraševali: kakšen je optimalen algoritem? Ampak, če ste tukaj, potem ste verjetno tudi poskusili napisati izvedbo te igre. Šli bomo dlje in napisali bota, ki ga bo nemogoče premagati v tic-tac-toe. Ko smo predvideli vaše vprašanje "zakaj?", vam bomo odgovorili: zahvaljujoč algoritmu.

Tako kot profesionalni šahist tudi ta algoritem izračunava dejanja nasprotnika za več potez naprej – dokler ne pride do konca partije, ne glede na to, ali gre za zmago, poraz ali remi. Ko je enkrat v tem končnem stanju, si bo AI dal pozitivno oceno (v našem primeru +10) za zmago, negativno oceno (-10) za poraz in nevtralno oceno (0) za remi.

Hkrati algoritem izvaja podobne izračune za igralčeve poteze. Izbral bo potezo z najvišjo oceno, če se AI premakne, in potezo z najnižjo oceno, če se igralec premakne. S to strategijo se minimax izogne porazu.

Poskusite igrati to igro.

Minimax algoritem je najpreprosteje opisan kot rekurzivna funkcija, ki:

vrne vrednost, če je najdeno končno stanje (+10, 0, -10),
gre skozi vse prazne celice na igrišču,
pokliče funkcijo minimax za vsakega od njih (rekurzija),
ovrednoti prejete vrednosti
in vrne najboljšega.

Če niste seznanjeni z rekurzijo, si oglejte to predavanje iz predmeta Harvard CS50:

Da bi razumeli, kako minimax deluje, napišimo njegovo izvedbo in modelirajmo njegovo obnašanje. S tem se bomo ukvarjali v naslednjih dveh razdelkih.

Minimax izvedba

Upoštevali bomo situacijo, ko se bo igra končala (glej spodnjo sliko). Ker gre minimax skozi vsa možna stanja igre (in teh je na sto tisoče), je smiselno razmisliti o koncu igre - na ta način moramo slediti manjšemu številu klicev rekurzivnih funkcij (skupaj 9).

Naj se AI igra s križci, moški - z ničlami.

Za poenostavitev dela s poljem ga razglasimo kot niz 9 elementov z vrednostmi, ki so enake vsebini celic. Napolnimo ga s križci in ničlami, kot na zgornji sliki, in ga poimenujmo origBoard.

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

Nato deklariramo spremenljivki aiPlayer in huPlayer in jima dodelimo vrednosti "X" oziroma "O".

Poleg tega potrebujemo funkcijo, ki išče zmagovalne kombinacije in vrne true, če je iskanje uspešno, ter funkcijo, ki shranjuje indekse razpoložljivih celic.

/* začetno stanje deske O | | X --------- X | | X --------- | O | O */ var origBoard = [“O”,1 ,”X”,”X”,4 ,”X”, 6 ,”O”,”O”]; // človek var huPlayer = “O”; // AI var aiPlayer = "X"; // vrne seznam indeksov praznih celic na tabli, function emptyIndices(board)( return board.filter(s => s != "O" && s != "X"); ) // zmagovalne kombinacije, upoštevajoč indeksi računa funkcija zmagovanje(deska, igralec)( if((deska == igralec && deska == igralec && deska == igralec) || (deska == igralec && deska == igralec && deska == igralec) || (deska == igralec && tabla == igralec && tabla == igralec) || (plošča == igralec && tabla == igralec && tabla == igralec) || (plošča == igralec && tabla == igralec && tabla == igralec) || (plošča == igralec && plošča == igralec && plošča == igralec) || (plošča == igralec && plošča == igralec && plošča == igralec) || (plošča == igralec && plošča == igralec && plošča == igralec)) ( vrni resnico; ) else ( vrni napačno; ) )

Torej definirajmo funkcijo minimax z dvema argumentoma: newBoard (nova tabla) in player (igralec). Nato na polju poiščemo indekse prostih celic in jih posredujemo spremenljivki availSpots.

// glavna funkcija minimax function minimax(newBoard, player)( //razpoložljive celice var availSpots = emptyIndices(newBoard);

Poleg tega moramo spremljati končna stanja in vrniti ustrezne vrednosti. Če zmaga ničla, morate vrniti -10 , če "križ" - +10 . Če je velikost matrike availSpots enaka nič, potem ni prostih celic, igra se bo končala z remijem in treba je vrniti nič.

// preveri stanje terminala (zmaga/poraz/neodločeno) //in ustrezno vrnitev vrednosti if (winning(newBoard, huPlayer))( return (score:-10); ) else if (winning(newBoard, aiPlayer)) ( return (rezultat:10); ) else if (availSpots.length === 0)( return (rezultat:0); )

Po tem morate zbrati točke iz vsake od praznih celic. Da bi to naredili, ustvarimo matriko potez in pojdimo skozi vse prazne celice, tako da indekse in rezultate vsake poteze vnesemo v objekt premikanja.

Nato nastavimo indeks prazne celice, ki je bila shranjena kot številka v origBoard, na lastnost indeks premikajočega objekta. Nato gremo za trenutnega igralca v prazno celico novega polja newBoard in pokličemo funkcijo minimax od drugega igralca in posledično polje newBoard. Po tem moramo lastnost rezultata predmeta, ki ga vrne funkcija minimax, vnesti v lastnost rezultata predmeta premikanja.

Če minimax ne najde končnega stanja, nadaljuje rekurzivno poglabljanje v igro, dokler ne doseže končnega stanja. Nato preide točke te "stopnje" rekurzije eno stopnjo višje.

Končno funkcija ponastavi newBoard in premakni predmet v matriko premikov.

// polje za shranjevanje vseh objektov var moves = ; // kroži po razpoložljivih celicah za (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 mora nato izbrati najboljšo potezo iz niza potez. Potrebuje potezo z najvišjo oceno, če gre za potezo z umetno inteligenco, in najmanjšo, če gre za potezo človeka. Torej, če je vrednost igralca aiPlayer, algoritem inicializira spremenljivko bestScore na zelo majhno število in preleti matriko potez: če poteza doseže več točk kot bestScore, si algoritem to potezo zapomni. V primeru potez z enakimi točkami si algoritem zapomni prvo.

V primeru, ko je igralec enak huPlayerju, je vse enako - le da se bestScore inicializira z velikim številom, minimax pa išče potezo z najmanjšim številom točk.

Končno minimax vrne objekt, shranjen v bestMove.

// če gre za potezo z umetno inteligenco, se pomikajte po potezah in izberite potezo z najvišjo oceno 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( // sicer se pomikajte po potezah in izberite potezo z najnižjo oceno var bestScore = 10000; for(var i = 0; i< moves.length; i++){ if(moves[i].score < bestScore){ bestScore = moves[i].score; bestMove = i; } } } // вернуть выбранный ход (объект) из массива ходов return moves; }

V naslednjem razdelku bomo simulirali naš program, da bomo razumeli, kako deluje.

Minimax v akciji

S pomočjo spodnjega diagrama bomo analizirali model algoritma korak za korakom.

Opomba: V diagramu velika števila označujejo redno številko klica funkcije, nivoji pa označujejo, za koliko premikov naprej je šel algoritem.

Algoritem se napaja z origBoard in aiPlayer. Naredi seznam treh najdenih praznih celic, preveri, ali je stanje končno, in preleti vse prazne celice. Algoritem nato spremeni newBoard tako, da aiPlayer postavi v prvo prazno celico. Po tem se pokliče iz newBoard in huPlayer in počaka na drugi klic, da vrne vrednost.
Medtem ko se prvi klic funkcije še vedno izvaja, se izvaja drugi, ki ustvari seznam dveh praznih celic, preveri, ali je stanje končno, in se zanka skozi vse prazne celice. Drugi klic nato spremeni newBoard tako, da huPlayer postavi v prvo prazno celico. Po tem se pokliče iz newBoarda in aiPlayerja in počaka na tretji klic, da vrne vrednost.
Ker je drugi klic našel dve prazni celici, minimax spremeni newBoard tako, da postavi huPlayer v drugo prosto celico. Nato se pokliče iz newBoard in aiPlayer.
Algoritem sestavi seznam praznih celic in popravi igralčevo zmago po preverjanju končnosti stanja. Zato vrne objekt s poljem štetja, ki je enako (-10).
Pri drugem funkcijskem klicu algoritem prejme vrednosti, vrnjene z nižje ravni s tretjim in četrtim funkcijskim klicem. Ker je poteza huPlayer ustvarila ta dva rezultata, algoritem izbere najmanjšega od njiju. Ker sta enaka, algoritem izbere prvega in ga posreduje prvemu klicu funkcije.

Na tej točki je prvi klic funkcije prejel oceno premika aiPlayerja v prvo prazno celico. Nato spremeni newBoard tako, da aiPlayer postavi v drugo prazno celico. Po tem se pokliče iz newBoard in huPlayer.
V petem klicu funkcije algoritem sestavi seznam praznih celic in popravi zmago AI po preverjanju končnosti stanja. Torej vrne predmet s poljem štetja +10.
Po tem prvi klic spremeni newBoard tako, da aiPlayer postavi v tretjo prazno celico. Nato se pokliče iz newBoard in huPlayer.
Šesti klic sestavi seznam dveh praznih celic, preveri, ali je stanje končno, in preleti vse prazne celice. Nato spremeni newBoard tako, da huPlayer postavi v prvo prazno celico. Nato se pokliče iz newBoarda in aiPlayerja in počaka na sedmi klic, da vrne vrednost.
Nov klic navede eno prazno celico, preveri, ali je stanje končno, in spremeni newBoard tako, da v prazno celico postavi aiPlayer. Po tem se pokliče iz newBoard in huPlayer in počaka, da ta klic vrne vrednost.
Osmi izziv je prazen seznam prazne celice in popravi zmago aiPlayerja po preverjanju končnosti stanja. Zato vrne objekt s poljem štetja, ki je enako (+10), eno raven višje, do sedmega klica.
Sedmi klic je prejel le eno, pozitivno vrednost z nižjih ravni. Ker je bila ta vrednost prejeta med potekom aiPlayerja, algoritem vrne največjo od prejetih vrednosti. Torej vrne pozitivno vrednost (+10) eno raven višje, do šestega klica.

Ker je šesti klic našel dve prazni celici, minimax spremeni newBoard tako, da huPlayer postavi v drugo prazno celico. Nato se pokliče iz newBoard in aiPlayer.
Po tem algoritem sestavi seznam praznih celic in popravi zmago aiPlayerja po preverjanju končnosti stanja. Zato vrne objekt s poljem štetja, ki je enako (+10) eno raven višje.
Na tej točki mora šesti klic izbrati med rezultatom (+10), ki ga vrne sedmi klic, in rezultatom (-10), ki ga vrne deveti klic. Ker je huPlayerjeva poteza prinesla ta dva rezultata, algoritem izbere najmanjšega od njiju in ga vrne na višjo raven kot objekt s polji za rezultat in indeks.

Na koncu se ovrednotijo vse tri veje prvega klica (-10, +10, -10). Ker je poteza aiPlayerja prinesla te tri rezultate, algoritem izbere objekt z najvišjo oceno (+10) in njegov indeks (4).

V zgornjem scenariju to odloči minimax najboljša izbira prišlo bo do premika v osrednjo celico polja.

Konec!

Do zdaj bi morali razumeti, kako deluje algoritem minimax. Poskusite sami napisati implementacijo ali si oglejte primer na GitHub ali CodePen in ga optimizirajte.

Če vas zanima tema AI v igrah, vam svetujemo, da preberete naše gradivo o tej temi.

1. KORAK. NASTAVITEV PARAMETROV OBRAZCA1. Če želite obrazec prilagoditi, nastavite njegovo velikost
510 vodoravnih pik in 480 navpičnih pik
navpično. Največ in najmanj
določite velikost, ki je enaka enakim vrednostim.
2. Poimenujte obliko z besedo "Tic Tac Toe".
3. Za ozadje obrazca uporabite datoteko iz mape
Slike pod imenom background.png in jo postavite
v središču obrazca.
4. Za ikono v naslovni vrstici
uporabi uporabi datoteko iz mape
Slike z imenom menu4.ico.
5. Nastaviti je treba barvo ozadja obrazca
MintCream.

2. KORAK. OBRAZCU DODAJTE GUMB IN RAZRED

1. Za postavljene elemente spremenite
velikost pisave na 12 in nastavljeno ozadje
pregleden.

1. Ustvarite menijsko vrstico z elementi
kot je prikazano na sliki.

KORAK 3. DODAJANJE MENIJSKE VRSTICE V OBRAZEC

1. V menijski točki Datoteka ustvarite ukaz
Izhod.
2. Za
ekipe
Izhod
predpisati
programska koda je enaka kot v
prejšnjo aplikacijo.

KORAK 3. DODAJANJE MENIJSKE VRSTICE V OBRAZEC

1. V menijski točki Igra ustvarite ekipo
Nova igra.
2. Za ekipo New Game pišite
programsko kodo v prihodnosti skozi
nekaj korakov.

KORAK 3. DODAJANJE MENIJSKE VRSTICE V OBRAZEC

1. V elementu menija Pomoč ustvarite ukaz
O programu.
2. Za ukaz About ustvarite novega
oblikovati in napisati programsko kodo
podobno kot v prejšnjem
aplikacija.

1. Tako, da povlečete PictureBox na obrazec
spremenite njegovo velikost na 100x100.
2. Nastavite prozorno ozadje.
3. Razporedite PictureBox, kot je prikazano v
številka nad prvo celico igralnega polja.

4. KORAK. OBRAZCU DODAJTE PICTUREBOX OBJEKTE

1
2
3
4
5
6
7
8
9
1. Nad ostalimi celicami, ki jih postavimo
Objekti PictureBox, kopije prvega
objekt, glede na oštevilčenje, navedeno na
Slike.

1. Preden napišete kodo
potrebno v mapi
\Visual Studio
2010\Projekti\Tic Tac Toe \ Tic Tac Toe
ničle\bin\Debug\ je treba preusmeriti
x.png, 0.png, none.png datoteke iz mape Slike.
2. Dvakrat kliknite z levo miško na prvo
PictureBox.

KORAK 5. DODAJTE KODO ZA PICTUREBOX OBJEKTE

1. Ustvarite dvodimenzionalni niz, ki je dostopen vsem elementom v
ustvarjen v obliki elementa 3x3, sestavljenega iz celih števil. Takoj
pri deklaraciji zapolnimo z ničlami. Za prazne celice mi
uporabili bomo 0, za "križce" - 1 in za "ničle" - -1.

KORAK 5. DODAJTE KODO ZA PICTUREBOX OBJEKTE

V postopku ob kliku na prvo
PictureBox, dodajanje operatorja
izbira
ki
volja
opravite preverjanje stanja
matrične celice. Če vrednost
celica polja bo 0, kar
To pomeni, da v njem ni "ničle".
"križ", potem v tej celici
polje je zapisano 1 in v
PictureBox1
prikazano
podobo »križa«, in če
vrednost celice polja bo
je enako 1, potem vsebuje
"križ" in vanj je zapisana 0, in
prikazana je prazna celica.

KORAK 5. DODAJTE KODO ZA PICTUREBOX OBJEKTE

1
2
3
4
5
6
7
8
9

Za preostale celice polja dodajte kodo
na enak način kot v prvem, le da se spreminja
Številka predmeta PictureBox in naslov celice
niz.
PRIMER za drugo celico:

Za postopek s klikom na gumb
dodati
operater
cikel
ki preverja
vse celice od prve do
prisotnost praznih celic. In če
celica je prazna
nato vanj
je zapisano "zero", in sicer v
celica polja je zapisana -1.
Za udobje pri prihodnjem delu
spremenljivke
jaz
j
ki
uporablja za ponavljanje zank
izjavi za celoten obrazec.

KORAK 6. DODAJTE PROGRAMSKO KODO ZA GUMB HOJA

Za prikaz ničel na
igranje
polje
potrebno
dodajte programsko kodo v telo
cikel preverjanja praznih celic.
Z ugnezdenim operaterjem
razvejanje
volja
odvijati se
razčlenjevanje naslova celice polja za
ničelni izhod v pravilnem
PictureBox.
Dodamo tudi izjavo o prekinitvi
za predčasni konec
zanke, ko je prazna
celice.

KORAK 6. DODAJTE PROGRAMSKO KODO ZA GUMB HOJA

Za prikaz stanja igre
se uporablja element vmesnika
Oznaka1. Ker se igralec vedno premika
prvi
to
pri
prenosi
aplikacije
potrebno
V
element
Oznaka1
potrebno
odražati
fraze "tvoj
premakniti."
Za
to
ustvariti
spremenljivka
odgovor
ki
Vzemimo ta stavek. A
pri nalaganju spremenljivke obrazca
mora biti dodeljen elementu
Label1, da ustvarite potrebno
postopkov
potrebno
najprej dvakrat kliknite
v obliki

KORAK 7. DODAJTE KODO ZA NOVO POSTAVKO MENIJA IGRE

Ko kliknete na ukaz novo
igra se bo ponastavila
vse celice v matriki, zamenjava vseh
"križce" in "ničice".
prazne celice. Tudi izhod
napis "Tvoja poteza"

KORAK 8. PRIKAŽI REZULTATE IGRE

Za preverjanje rezultatov potez
potrebno
analizirati
vsebino vrstic, stolpcev in
diagonale. Če vsi trije elementi
so enaki 1, potem je to zmaga za igralca in
če trije -1 je to poraz
igralec.
Zahtevano je preverjanje zmage
ravnanje
prej
premakniti
računalnik,
A
preverjanje
poraz po.
Zadnji ukaz postopka
bo prikazal rezultate
premakniti.

KORAK 8. PRIKAŽI REZULTATE IGRE

Programska koda za preverjanje zmage uporabnika:
if (znacheniyeYacheyki == 1 && znacheniyeYacheyki == 1 && znacheniyeYacheyki == 1) otvet = "Zmagal si";
if (znacheniyeYacheyki == 1 && znacheniyeYacheyki == 1 && znacheniyeYacheyki == 1) otvet = "Zmagal si";
if (znacheniyeYacheyki == 1 && znacheniyeYacheyki == 1 && znacheniyeYacheyki == 1) otvet = "Zmagal si";
if (znacheniyeYacheyki == 1 && znacheniyeYacheyki == 1 && znacheniyeYacheyki == 1) otvet = "Zmagal si";
if (znacheniyeYacheyki == 1 && znacheniyeYacheyki == 1 && znacheniyeYacheyki == 1) otvet = "Zmagal si";
if (znacheniyeYacheyki == 1 && znacheniyeYacheyki == 1 && znacheniyeYacheyki == 1) otvet = "Zmagal si";
if (znacheniyeYacheyki == 1 && znacheniyeYacheyki == 1 && znacheniyeYacheyki == 1) otvet = "Zmagal si";
if (znacheniyeYacheyki == 1 && znacheniyeYacheyki == 1 && znacheniyeYacheyki == 1) otvet = "Zmagal si";
Programska koda za preverjanje zmage uporabnika:
if (znacheniyeYacheyki == -1 & znacheniyeYacheyki == -1 & znacheniyeYacheyki == -1) otvet = "Izgubili ste";
if (znacheniyeYacheyki == -1 & znacheniyeYacheyki == -1 & znacheniyeYacheyki == -1) otvet = "Izgubili ste";
if (znacheniyeYacheyki == -1 & znacheniyeYacheyki == -1 & znacheniyeYacheyki == -1) otvet = "Izgubili ste";
if (znacheniyeYacheyki == -1 & znacheniyeYacheyki == -1 & znacheniyeYacheyki == -1) otvet = "Izgubili ste";
if (znacheniyeYacheyki == -1 & znacheniyeYacheyki == -1 & znacheniyeYacheyki == -1) otvet = "Izgubili ste";
if (znacheniyeYacheyki == -1 & znacheniyeYacheyki == -1 & znacheniyeYacheyki == -1) otvet = "Izgubili ste";
oznaka1.besedilo = odgovor;

KORAK 9 IZBOLJŠAJTE "IGRALNOST"

Za izboljšanje igralnosti
namesto serijskega izhoda
v prvem praznem
celice "ničle", izvajamo
izhod prek naključnega generatorja
številke.
Za to morate dodati
eno logično spremenljivko
uslovie in spremenite vrsto zanke iz For
na Medtem, ker ne vemo
točno število ponovitev
generator naključna števila adijo
ne bo padel v prazno celico.

MINISTRSTVO ZA IZOBRAŽEVANJE IN ZNANOST RUSIJE

zvezna državna proračunska izobraževalna ustanova višjega strokovnega izobraževanja

"Državna univerza Vologda"

Katedra za avtomatiko in računalništvo

Pojasnilo k predmetnemu projektu o disciplini

Programiranje in osnove algoritmizacije

"Križci in krožci"

Izpolnjenoštudent skupine EM-21

Butorova L.Yu.

sprejeto Rzheutskaya S. Yu.

UVOD

1. ANALIZA PROBLEMA IN DOLOČITEV ZAHTEV ZA RAZVITA PROGRAM

1 Namen programa, njegovi uporabniki, glavne funkcije in cilji, ki jih zasledujemo med razvojem

2 Pregled dobro znanih programov, ki izvajajo podobne funkcije

3 Teoretične osnove razvoja

4 Izbira razvojnih orodij

OBLIKOVANJE DEL RAZVOJA

1 Oblikovanje uporabniškega vmesnika

2.2 Razvoj podatkovnih struktur (v zunanjem in RAM)

2.3 Razvoj in analiza algoritmov

IZVEDBA PROGRAMA V C++

1 Arhitektura programa

2 Izbor standardnih vizualnih in nevizualnih komponent

REZULTATI TESTOV

ZAKLJUČEK

Bibliografija

Aplikacije

UVOD

Tic-tac-toe - logična igra med dvema nasprotnikoma na kvadratnem polju 3 x 3 celice ali večjem (do "neskončnega polja"). Eden od igralcev igra s "križi", drugi - z "ne". Ta igra je postala priljubljena že dolgo pred pojavom računalnikov, le prej so jo igrali s preprostim kosom papirja in pisalom. Tradicionalna kitajska igra uporablja črne in bele kamne.

V tem seminarska naloga osnovna pravila in standardna velikost igralnega polja (3x3 celice) so ohranjena. Za udobje igre je pravica do prve poteze prepuščena uporabniku, to je "križ".

Tic-tac-toe je program, ki je zasnovan za zabavo uporabnika, zato je njegov vmesnik v tem tečaju narejen v slogu igre s kombinacijo pozitivnih barv, ki poudarijo čustveni del igranja.

V igri so tri vrste: X proti 0 - uporabnik proti uporabniku, "1 stopnja z računalnikom" - za tiste, ki se šele učijo osnov svetovne igre, in stopnja "2 stopnja z računalnikom" - za tiste, ki so popolnoma prepričani v svojo zmago. Na stopnjah 1 in 2 so možni trije izidi: "zmaga", "izguba" in "neodločeno". Dobitek je fiksen, če je navpična, vodoravna ali diagonalna v celoti zapolnjena s križci ali ničlami.

Če je prostih celic na igrišču konec, vendar nihče ni zmagal, se šteje, da se je igra končala z "remijem".

1. ANALIZA PROBLEMA IN DOLOČITEV ZAHTEV ZA RAZVITA PROGRAM

programski navzkrižni vmesnik

1.1 Namen programa, njegovi uporabniki, glavne funkcije in cilji med razvojem

Namen tega programa je predvsem zabavati uporabnike, da bi človeku polepšali čakalni čas, saj vsako delo potrebuje počitek, ta preprosta igra pa vam bo pomagala, da se sprostite in odvrnete od vsakdanjih zadev. Tudi "tic-tac-toe" spada v razred intelektualnih in logičnih iger, ki so zasnovane za urjenje logičnega razmišljanja, vam omogočajo koncentracijo in razvoj spomina.

Ciljna publika uporabnikov so otroci in najstniki ter odrasli. Glavno merilo za uporabo izdelka je zmožnost branja besedila, zapisanega v programu, in zmožnost izbire potrebne naloge za računalnik s pomočjo gumbov.

Iz tega lahko sklepamo, da sta glavni nalogi: naloga zabave in naloga razvijanja logičnega potenciala osebe.

1.2 Pregled znanih programov, ki opravljajo podobne funkcije

Na internetu lahko najdete veliko število del, ki izvajajo to igro. Trenutno obstaja veliko analogov te igre, ki so se oddaljili od prvotnih standardov. Primera takih programov sta Tic-Tac-Toe na neskončnem polju in Tic-Tac-Toe 3D. Prav tako so v mnogih igrah "križi" in "prsti" nadomeščeni z drugimi simboli, kot so na primer "kamni".

Moj tečajni projekt je aplikacija za osebni računalnik. Igra je zasnovana tako za enega uporabnika, katerega nasprotnik je umetna inteligenca (ali računalnik), kot za dva uporabnika. Predstavljen je na klasičnem polju 3x3.

Najbolj zanimiva in nenavadna je bila po mojem mnenju igra "Tic Tac Toe 3D". Zato sem ga izbral za primerjavo.

Tridimenzionalni tic-tac-toe je veliko bolj zanimiv kot na papirju ali na običajnem polju. Tu je več priložnosti za zmago in poraz, remi pa so redkejši. Igrate lahko sami - proti računalniku - ali skupaj s prijateljem. In najbolj nenavadno pri tem je, da lahko za zmago sestavite kombinacijo treh kroglic svoje barve (črne ali bele) ne samo na kateri koli ravni, temveč tudi vzdolž ravnine sten in celo vzdolž diagonale celotnega polje (slika 1.1).

riž. 1.1

Med široko paleto iger podobne teme lahko v vsakem delu ločimo edinstveno izvedbo načrta. Vsak projekt se od drugih razlikuje po svoji individualnosti.

1.3 Teoretične osnove razvoja

Analiza

Za vsako od strank so dobro znani algoritmi, ki zagotavljajo neodločen izid v kateri koli partiji nasprotnika, če ta naredi napako, pa ti omogočijo zmago. Igra je torej v stanju "nikogaršnja smrt"<#"877528.files/image002.gif">

Slika 1.2. Drevo igralnih situacij

Delno drevo igralnih situacij je prikazano na sliki 1.2 za igro tic-tac-toe. Drevo igralnih situacij za igro tic-tac-toe, kjer igralec za "tic-tac-toe" gre prvi in deluje po zgornjem algoritmu, igralec za "tac-toe" pa lahko dela kar hoče (poleg tega je eno vozlišče podano za racionalno in za iracionalno dejanje, torej vsako drugo), je sestavljeno iz 50 vozlišč.

1.4 Izbira razvojnih orodij

Za izvajanje naših nalog je potrebno integrirano okolje za razvoj aplikacij. Zato je bil projekt razvit v programskem okolju Microsoft Visual Studio 2008.

Microsoft Visual Studio - Microsoftova linija izdelkov , vključno z integriranim razvojnim okoljem programsko opremo in vrsto drugih orodij. Ti izdelki vam omogočajo razvoj kot konzola aplikacije kot tudi aplikacije GUI , vključno s podporo za tehnologijo Windows Forms kot tudi spletne strani , spletne storitve kot v domačem , in v nadzorovanem kode za vse platforme, ki jih podpira Windows Windows Mobile , Windows CE , .NET Framework , Xbox , Windows telefon .NET Compact Framework in Silverlight .

2. PROJEKTIRANJE DEL RAZVOJA

2.1 Oblikovanje uporabniškega vmesnika

Pri ustvarjanju aplikacije za igre je treba upoštevati eno glavnih sestavin uspeha izdelka - to je vmesnik. Uporabniški vmesnik programa mora biti v prvi vrsti uporabniku razumljiv in privlačen. Poskušati morate odstraniti vse trenutke, ki bodo uporabnika odvrnili ali mu povzročili nelagodje. Celoten vmesnik programa lahko razdelimo na dve komponenti.

) Glavni meni programa

riž. 2.1 - Glavni meni programa

Glavni meni je zasnovan tako, da omogoča uporabniku, da se pridruži igričarskemu vzdušju, zato je vmesnik narejen v pisanih, igrivih barvah. Preko menija lahko greste na igralno polje, si ogledate pravila igre ali zapustite igro.

) igrišče

Slika 2.2 – Igralno polje

Igralno polje vsebuje neposredno območje za igro, kjer igralec in računalnik postavita svoje ikone. Pred začetkom igre mora uporabnik izbrati vrsto igre, kot je "X proti 0", "1 stopnja z računalnikom" ali "2 stopnja z računalnikom", sicer bo program pozval sporočilo, ki vam bo povedalo, kaj storiti. Gumb, ki bo igralcu pomagal pri vrnitvi v glavni meni. Na koncu se bodo pojavila dodatna okna, ki bodo udeleženca obvestila o rezultatih dvoboja.

riž. 2.3 - dodatna okna z izidi igre

2.2 Razvoj podatkovnih struktur (v zunanjem in RAM)

RAM se uporablja za enodimenzionalni niz, sestavljen iz 9 elementov, ki hrani stanja igralnega polja, kjer vsaka celica niza ustreza celici na igralnem polju. Pomnilnik se porabi tudi za statične spremenljivke: številko stopnje, vrstni red.

Za delovanje potrebuje 803 KB prostega pomnilnika.

.3 Razvoj in analiza algoritmov

Če želite implementirati algoritem razmišljanja o igri, morate določiti statično polje gcnew array (9); v kateri bodo shranjena stanja igralnega polja, kjer vsaka celica matrike ustreza celici. "0" - ustreza prazni celici, če je igralec šel v celico, to je "X", se zabeleži vrednost "1" in če je računalnik naredil potezo, to je "O", je vrednost "2". Na začetku so vsi elementi matrike enaki "0". Nastaviti morate statično spremenljivko lvl, ki shranjuje podatke o ravni. V tej igri so skupaj 3 ravni: lvl ima vrednost "1", če je uporabnik izbral vrsto igre "X proti O", vrednost "2", če je "1 stopnja z računalnikom", in vrednost " 3«, če je »2 raven z računalnikom«. Spremenljivka igralec - shrani vrstni red potez ("true" - poteza igralca, "false" - poteza računalnika). Ker je pravica do prve poteze podeljena uporabniku, je na začetku igre igralec = true. Statična spremenljivka zastavice shranjuje informacije o tem, ali so na igralnem polju prazne celice ali ne: če je zastavica = true – to je false – ni praznih celic. Verifikacijski algoritem mora vsebovati naštevanje parametrov matrike x in predlagati lastno rešitev, ki bo optimalna za nadaljnjo igro. Ta program predstavlja 2 ravni igre z računalnikom. Na ravni 1 naloga računalnika ni premagati nasprotnika. Zato dano funkcijo vrne naključno vrednost celice, kamor bo šel računalnik. Koda tega algoritma je predstavljena v [Dodatek 1]. Slika 2.4 prikazuje blokovni diagram implementacije kode.

Najbolj zmagovalna poteza na začetku igre je premik na sredino igrišča. V funkciji dif_level() se na začetku preveri pogoj: če igralec ni šel na osrednje polje, gre tja računalnik. V nasprotnem primeru, če je igralec šel na sredino, se pokliče funkcija check(2), ki preveri kombinacijo računalnika in, če je možno zmagati, vrne številko celice. Če računalnik ne more zmagati pri naslednji potezi, se pokliče funkcija check(1): preverjanje igralčeve kombinacije. Vrne se številka celice, stava, v kateri bi igralec zmagal. Če takšne kombinacije ni, se pokliče funkcija low_level().

Slika 2.4. - Diagram poteka

Slika 2.5. - Diagram poteka

3. IMPLEMENTACIJA PROGRAMA V C++

.1 Arhitektura programa

Ta program izvaja 3 oblike: glavni meni (slika 2.1.), igralno polje (slika 2.2) in polje za pomoč (pravila igre); 12 plošč, od tega 9 glavnih. Prav tako se na koncu igre pojavi slikovno polje z rezultatom, skupaj jih je 5 (slika 2.3).

Za osnovo lahko vzamete obdelovalce klikov plošče, ki jih je natanko 9 na igralnem polju. Vsak upravljavec pokliče več funkcij. Na začetku je pogoj, da če uporabnik izbere vrsto igre "X proti 0", se samo celice zapolnijo z vrednostmi 1 ali 2 (križ ali nič). Sledijo funkcije: indikacija poteze (CrossZero()), ki spremeni križec v ničlo in obratno, blokiranje zasedenih celic s checkingArray(), iskanje zmagovalca winner(). V funkciji winner() se upoštevajo vse možne možnosti dobitka, zato bo zmagal, če eden od igralcev postavi 3 svoje figure (križ ali nič) v vrsto navpično, vodoravno ali diagonalno. V nasprotnem primeru, če je polje zapolnjeno, vendar se nobeden od igralcev ni postavil v vrsto, se pokliče funkcija (_friend()) - preveri žrebanje, ki preveri, ali so na polju proste celice ali ne. Če je fr = true, potem na polju ni prostih celic. Če se je vrednost spremenila, je na polju prosta celica.

Drugi pogoj deluje, če je izbrana druga ali tretja vrsta igre. Nato se pokliče funkcija, v kateri se izvede premik računalnika move(int n). Prejme številko celice, na katero je igralec kliknil. Sledijo funkcije: indikacija napredka (CrossZero()), blokiranje zasedenih celic s checkingArray(). Nato se pokliče funkcijawinner(), ki preveri, ali je igralec zmagal to potezo ali ne. Če ne, se preveri prisotnost prostih celic. Če so proste celice, se računalnik premakne. Nadalje, odvisno od tega, katero raven je igralec izbral "1" ali "2", se pokličejo naslednje funkcije: low_level(), dif_level(). Funkcija low_level() naključno izbere, kam naj postavi ničlo, funkcija dif_level() pa nudi poseben algoritem za zmago računalnika. Sledijo funkcije: indikacija napredka (CrossZero()), blokiranje zasedenih celic s checkingArray(). Nato se pokliče funkcija winner(), ki preveri, ali je računalnik to potezo zmagal ali ne. Če ne, se preveri prisotnost prostih celic. Če so proste celice, se igralec premakne.

.2 Izbira standardnih vizualnih in nevizualnih komponent

Za izvedbo tega dela so bile izbrane naslednje komponente:

1) Obrazec1, z danih parametrov Text=Tic Tac Toe, ControlBox=False

2) f2, z nastavljeno BackColor, Text=Game

) comboBox1 z danimi možnostmi elementov:

X proti 0

1. stopnja z računalnikom

2. stopnja z računalnikom

4) plošča z danimi parametri BackColor in različnimi vrednostmi parametrov Visible in Enabled. Za nekatere plošče so bili napisani dogodki, kot je Click.

5) gumb z določenimi parametri Pisava, Barva sprednjega dela, Barva ozadja, Besedilo, za vse gumbe so bili zapisani dogodki, kot je Klik.

6) nalepka z danimi parametri BackColor , Font, Fore Color, Text.

) pictureBox, z nastavljenimi parametri slike, SizeMode= StretchImage.

) textBox, z danimi parametri BackColor, Font, Fore Color, Text=” ”.

4. REZULTATI TESTA

Preizkusimo program tako, da gremo skozi 3 vrste iger.

Poskusimo dejanja gumbov glavnega menija. Gumbi delujejo pravilno. Poskusimo začeti igro brez izbire vrste igre. Program prikaže sporočilo o napaki in vas pozove, da izberete vrsto igre (slika 4.1).

Slika 4.1.

Izberimo 1 vrsto igre - "X proti 0", tj. uporabnik proti uporabniku. Na tej stopnji igre se lahko uporabnik igra tudi sam s seboj. (Slika 4.2)

Slika 4.2.

Med igro "1 stopnja z računalnikom" si računalnik ne zastavi cilja zmagati udeleženca. Samo vstavi ničle prosta mesta polja. Na tej stopnji lahko uporabnik zlahka premaga računalnik. Čeprav so na tej ravni možni tudi drugi scenariji.

Slika 4.3.

Vrsta igre "Raven 2 z računalnikom". Na tej stopnji igra analizira vse poteze in poskuša izbrati najbolj optimalno potezo. Tu so možne tudi vse tri različice razvoja dogodkov, saj Računalnik se prvič premakne v katero koli prosto celico. Večino časa se igra konča z remijem.

Slika 4.4.

Program teče uspešno na vseh testnih variantah, brez napak.

ZAKLJUČEK

Lahko rečemo, da je naloga, zastavljena na začetku dela, opravljena. Med razvojem je bil načrtovan in razvit projekt remiksov znane igre Tic-Tac-Toe. Igra izpolnjuje navedene zahteve in opravlja svoje funkcije. Implementirano v delu Različne vrste igre in težavnostne stopnje.

Med delom smo osvojili nove metode programiranja v integriranem razvojnem okolju. Staro znanje dela z jezikom C ++ je popravljeno. Pri pripravi tečaja so bile analizirane različne metode in algoritmi za izvajanje te igre.

Kljub navidezni preprostosti tega programa je poln številnih težav, ki se izvajajo z uporabo vseh osnovnih tehnik Visual C ++.

Značilnosti tega programa so:

Jasno sestavljen algoritem;

Intuitiven vmesnik;

Enostavnost uporabe;

Popolnoma jasen uporabniški priročnik;

Brez dodatnih dodatkov.

BIBLIOGRAFIJA

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

PRILOGA 1

zasebno: int low_level()(// postopek za nizkega nasprotnika;::Random^ rand = gcnew System::Random();(= rand->Next(0,8);

) medtem ko (x[r] != 0);r;

PRILOGA 2

zasebno: bool check(int n)(k = -1;// preveri vse kombinacije in vrne pravilno potezo(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) vrni resnično; sicer vrni napačno;

PRILOGA 3

zasebno: int dif_level()(//težak nasprotnik

//vrni ček(2);(x == 0) vrni (4);(preveri(2)) vrni k; else (preveri(1)) vrni k; sicer nizka_nivo();

UPORABA 4

zasebno: void CrossZero()(// spremeni križec v nič (indikator napredka)(igralec) (->Visible = true;->Visible = false;

) else (->Visible = true;->Visible = false;

): void checkingArray()(// funkcija za preverjanje, ali je v celici nekaj, če je, potem ne morete več klikniti te celice. >Omogočeno = false;)(x == 2) (panel1-> BackgroundImage = panel10->BackgroundImage;panel1->Enabled = false;)(x == 1) (panel2->BackgroundImage = panel11->BackgroundImage;panel2- >Enabled = false;)(x == 2) (panel2-> BackgroundImage = panel10->BackgroundImage;panel2->Enabled = false;)(x == 1) (panel3->BackgroundImage = panel11->BackgroundImage;panel3- >Enabled = false;)(x == 2) (panel3-> BackgroundImage = panel10->BackgroundImage;panel3->Enabled = false;)(x == 1) (panel4->BackgroundImage = panel11->BackgroundImage;panel4- >Enabled = false;)(x == 2) (panel4-> BackgroundImage = panel10->BackgroundImage;panel4->Enabled = false;)(x == 1) (panel5->BackgroundImage = panel11->BackgroundImage;panel5- >Enabled = false;)(x == 2) (panel5-> BackgroundImage = panel10->BackgroundImage;panel5->Enabled = false;)(x == 1) (panel6->BackgroundImage = panel11->BackgroundImage;panel6- >Enabled = false;)(x == 2) (panel6-> BackgroundImage = panel10->BackgroundImage;panel6->Enabled = false;)(x == 1) (panel7->BackgroundImage = panel11->BackgroundImage;panel7- >Enabled = false;)(x == 2) (panel7-> BackgroundImage = panel10->BackgroundImage;panel7->Enabled = false;)(x == 1) (panel8->BackgroundImage = panel11->BackgroundImage;panel8- >Enabled = false;)(x == 2) (panel8-> BackgroundImage = panel10->BackgroundImage;panel8->Enabled = false;)(x == 1) (panel9->BackgroundImage = panel11->BackgroundImage;panel9- >Enabled = false;)(x == 2) (panel9-> BackgroundImage = panel10->BackgroundImage;panel9->Enabled = false;)

): bool winner()(// preveri zmagovalca in blokira vse preostale celice.

//bool zastavica = 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->Visible = true;)(picturePr->Visible = true;)->Enabled = false;->Enabled = false;->Enabled = false;->Enabled = false;-> 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->Visible = true;)(picturePobeda->Visible = true;)->Enabled = false;->Enabled = false;->Enabled = false;->Enabled = false;->Enabled = false;- > Omogočeno = false;->Omogočeno = false;->Omogočeno = false;->Omogočeno = false; true;

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

): void move(int n)(// funkcija premikanja računalnika= 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^ sender, System::EventArgs^ e) (// nova igra>Visible = false;>Visible = false;>Visible = false; >Visible = false; >Visible = false; = comboBox1->Text;(typeGame == "")(::Show("Najprej izberite vrsto igre!");

) else ((typeGame == "X proti 0") lvl = 1;(typeGame == "Raven računalnika 1") lvl = 2;(typeGame == "Raven računalnika 2") lvl = 3;(); = true ;(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 = panel12-> BackgroundImage;->BackgroundImage = panel12->BackgroundImage;->BackgroundImage = panel12->BackgroundImage;->BackgroundImage = panel12->BackgroundImage;->Enabled = true;->Enabled = true;->Enabled = true;->Enabled = true;->Enabled = true;->Enabled = true;->Enabled = true;->Enabled = true;->Enabled = true;

): System::Void panel1_MouseClick(System::Object^ pošiljatelj, System::Windows::Forms::MouseEventArgs^ e) (n = 0;(lvl == 1)((igralec)( = 1;

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

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

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