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

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

Lep pozdrav, dragi prijatelji! V tej lekciji 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 celice (po možnosti večje). Eden igra s "križi", drugi pa s "prsti na nogah".

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

Opis igre, ki se ustvarja

Oglejmo si značilnosti igre:

igra se začne takoj po nalaganju strani;
pravica do prvega se izbere naključno (ali začnete hoditi ali računalnik);
znak, na katerega boste stavili, je izbran naključno (križec ali ničla);
č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 si izmislil zapletenih (univerzalnih) algoritmov za igralno polje 3 krat 3 kvadrate, šel sem v drugo smer - surovo silo! (več o tem malo kasneje). Identificiral sem tri glavne zaporedne stopnje, na katerih temelji vsa logika:

1. stopnja: preverjanje, 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 poteza (tudi prva), vedno najprej preverimo, ali je igralec zmagal. Takole izgleda zmaga:

2. stopnja: preveri - ali lahko računalnik zmaga z naslednjo potezo?

Na tej stopnji iščemo linijo, kjer bi bili 2 celici, ki bi jih zapolnil računalnik, in ena prazna celica - to pomeni, da poskušamo zmagati zaradi nepazljivosti igralca. Takole izgleda poraz (torej računalniška zmaga):

3. stopnja: ne dovolimo vam zmagati!

Tukaj iščemo isto vrstico kot v drugi fazi, le 2 celici morata biti napolnjeni z znaki igre igralca, to pomeni, da na tej stopnji ne dovolimo, da bi računalnik izgubil s postavitvijo znaka v prazno celico. Vsaka od stopenj predstavlja neodvisno funkcijo - 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 postavitev celic:

Ti si na vrsti!

Celica pomožnega razreda je potrebna za natančno identifikacijo želene celice na igrišču. 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)); 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"]; //Določi zmagovalno funkcijo igralca 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 predznak, s katerim bo uporabnik igral (privzeto je tam shranjena ničla - to je angleško polje "O"). znak_comp - v tej spremenljivki shranimo znak, s katerim bo računalnik igral (privzeto je tam shranjen križec - to je angleški kvadrat "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, kot vam ustreza, na primer lahko ustvarite več naključnih števil, da naredite več možnosti za to, kdo bo prvi in kakšne znake. exit_flag - ta zastavica (spremenljivka) je odgovorna za izhod iz funkcije, to je na primer, ko je računalnik že opravil svojo potezo in morate zapustiti funkcijo in prenesti potezo igralcu. 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 številk, kar je zmagovalna kombinacija, to je, če na primer izpolnite celice pod številkami 1, 2 in 3, potem bo prišlo do zmage (ali poraza). Kot lahko vidite, je skupno 8 zmagovalnih možnosti; naša naloga je, da gremo skozi 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 v polju. Vsaki od funkcij se posreduje parameter (znak) - to je znak igralca ali računalnika (križec ali ničla), na primer funkciji, ki določa zmago igralca (check_3_user), posredujemo znak igralca po vrstnem redu. najti 3 enake znake na isti črti.

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), najprej stavite vanjo; če je zasedena, 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 vaše presoje.

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

Zdaj si lahko ogledate igro z demo primerom in prenesete izvorno datoteko (skupaj 1 datoteka).

08.06.2018 - hvala za vašo pozornost avtorju pisma: Patvakan Baghdasaryan, napaka je bila odpravljena, ko je imel računalnik več možne možnosti 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 lekcija 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

Povsem mogoče 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 pri tik-tak-tou. Predvidevamo vaše vprašanje "zakaj?", Bomo odgovorili: zahvaljujoč algoritmu.

Tako kot profesionalni šahist ta algoritem nasprotnikova dejanja izračunava več potez naprej – dokler ne pride do konca partije, pa naj gre za zmago, poraz ali remi. Ko je enkrat v tem končnem stanju, si bo AI dodelil pozitivno število točk (v našem primeru +10) za zmago, negativno (-10) za poraz in nevtralno (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, če se igralec premakne. S to strategijo se minimax izogne porazu.

Poskusite igrati to igro.

Minimax algoritem je najlažje opisati kot rekurzivno funkcijo, ki:

vrne vrednost, če je najdeno končno stanje (+10, 0, -10),
gre skozi vse prazne celice na polju,
pokliče funkcijo minimax za vsakega od njih (rekurzija),
ovrednoti dobljene 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

Ogledali si bomo situacijo, ko se igra bliža koncu (glej sliko spodaj). Ker gre minimax skozi vsa možna stanja igre (in teh je na sto tisoče), je smiselno razmisliti o koncu igre - tako bomo morali slediti manjšemu številu klicev rekurzivnih funkcij (skupaj 9).

Naj se AI igra s križci, oseba - z ničlami.

Za lažje delo s poljem ga razglasimo kot niz 9 elementov z vrednostmi, ki so enake vsebini celic. Napolnimo jo s križci in prsti, kot je na zgornji sliki, in jo poimenujmo origBoard.

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

Nato bomo deklarirali spremenljivki aiPlayer in huPlayer ter jima dodelili vrednosti "X" oziroma "O".

Poleg tega bomo potrebovali funkcijo, ki išče dobitne kombinacije in vrne pravo vrednost, č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”]; // oseba 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 ob upoštevanju indeksi funkcija zmaga(deska, igralec)( if((deska == igralec && deska == igralec && deska == igralec) || (deska == igralec && deska == igralec && deska == igralec) || (deska = = igralec && tabla == igralec && tabla == igralec) || (tabla == igralec && tabla == igralec && tabla == igralec) || (tabla == igralec && tabla == igralec && tabla == igralec) || | (deska == igralec && tabla == igralec && tabla == igralec) || (deska == igralec && tabla == igralec && tabla == igralec) || (deska == igralec && tabla == igralec && tabla = = igralec)) ( vrni resnično; ) else ( vrni napačno; ) )

Torej definirajmo funkcijo minimax z dvema argumentoma: newBoard in player. Nato bomo na polju našli indekse prostih celic in jih posredovali 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č.

// preverjanje stanja terminala (zmaga/izguba/neodločeno) //in vrnitev ustrezne 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, bomo ustvarili niz potez in šli skozi vse prazne celice v zanki, pri čemer bomo indekse in točke vsake poteze postavili v predmet premika.

Nato nastavimo indeks prazne celice, ki je bila shranjena kot število v origBoard, enaka lastnosti indeksa premikajočega objekta. Nato bomo šli kot trenutni igralec v prazno celico novega polja newBoard in poklicali funkcijo minimax od drugega igralca in posledično polje newBoard. Po tem morate lastnost rezultata predmeta, ki ga vrne funkcija minimax, vnesti v lastnost rezultata predmeta premika.

Če minimax ne najde končnega stanja, se še naprej rekurzivno pomika globlje v igro, dokler ne doseže končnega stanja. Nato prenese točke te "nivoja" rekurzije na en nivo višje.

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

// polje za shranjevanje vseh objektov var moves = ; // pomikajte se 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 se premika AI, in z najnižjo, če gre za človeško potezo. Torej, če je vrednost igralca aiPlayer, algoritem inicializira spremenljivko bestScore na zelo majhno število in preleti matriko potez: če je rezultat poteze vreden 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 podobno - le da se bestScore inicializira na veliko število, minimax pa išče potezo z najmanj točkami.

Kot rezultat, minimax vrne objekt, shranjen v bestMove.

// če je to poteza z umetno inteligenco, se pomikajte po potezah in izberite potezo z največ točkami 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 najmanj točkami 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 velike številke označujejo zaporedno številko funkcijskega klica, ravni pa označujejo, za koliko premikov je algoritem šel naprej.

OrigBoard in aiPlayer se posredujeta algoritmu. Naredi seznam treh najdenih praznih celic, preveri končnost stanja in preleti vse prazne celice. Algoritem nato spremeni newBoard in postavi aiPlayer v prvi prazen kvadrat. 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 drugi izvaja, ustvarja seznam dveh praznih celic, preverja končno stanje in kroži skozi vse prazne celice. Drugi klic nato spremeni newBoard tako, da postavi huPlayer v prvo prazno polje. 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 huPlayer postavi v drugo prazno celico. Nato se pokliče iz newBoard in aiPlayer.
Algoritem sestavi seznam praznih celic in zabeleži zmago igralca po preverjanju končnosti stanja. Torej vrne predmet z rezultatskim poljem (-10).
Pri drugem funkcijskem klicu algoritem prejme vrednosti, vrnjene z nižje ravni s tretjim in četrtim funkcijskim klicem. Ker je poteza huPlayerja povzročila ta dva rezultata, algoritem izbere manjšega. 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 polje. Po tem se sam pokliče iz newBoard in huPlayer.
V petem klicu funkcije algoritem sestavi seznam praznih celic in zabeleži zmago AI po preverjanju končnosti stanja. Torej vrne predmet z rezultatskim poljem +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 izpiše seznam dveh praznih celic, preveri končnost stanja in preleti vse prazne celice. Nato spremeni newBoard tako, da huPlayer postavi v prvo prazno polje. Nato se pokliče iz newBoarda in aiPlayerja in počaka na sedmi klic, da vrne vrednost.
Novi klic sestavi seznam ene prazne celice, preveri končno stanje in spremeni newBoard, da aiPlayer postavi v prazno celico. 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 zabeleži zmago aiPlayerja po preverjanju stanja okončin. Zato vrne objekt s poljem štetja, ki je enako (+10), na zgornjo raven, sedmi klic.
Sedmi klic je prejel le eno, pozitivno vrednost z nižjih ravni. Ker je bila ta vrednost pridobljena med potezo aiPlayerja, algoritem vrne največjo pridobljeno vrednost. Torej vrne pozitivno vrednost (+10) na raven navzgor, šesti klic.

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 zabeleži zmago aiPlayerja po preverjanju končnosti stanja. Zato vrne predmet z rezultatskim poljem enakim (+10) na zgornjo raven.
Na tej točki mora šesti izziv izbrati med rezultatom (+10), ki ga je vrnil sedmi izziv, in rezultatom (-10), ki ga je vrnil deveti izziv. Ker je poteza huPlayerja povzročila ta dva rezultata, algoritem izbere manjšega in ga vrne na naslednjo 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 dala te tri rezultate, algoritem izbere objekt z največjim številom točk (+10) in njegov indeks (4).

V zgornjem scenariju to odloči minimax optimalna izbira bo premik na osrednji trg igrišča.

Konec!

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

Če vas zanima tema AI v igrah, priporočamo, da preberete naše gradivo o tej temi.

1. KORAK. KONFIGURIRANJE PARAMETROV OBRAZCA1. Če želite prilagoditi obrazec, nastavite njegovo velikost
510 pik vodoravno in 480 pik vodoravno
navpično. Največ in najmanj
navedite velikost, ki je enaka enakim vrednostim.
2. Poimenujte obliko "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 pod imenom menu4.ico.
5. Barva ozadja obrazca mora biti nastavljena
MintCream.

KORAK 2. DODAJANJE GUMBKA IN OZNAKE V OBRAZEC

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 elementu menija Datoteka ustvarite ukaz
Izhod.
2. Za
ekipe
Izhod
predpišemo
programska koda je enaka kot pri
prejšnjo aplikacijo.

KORAK 3. DODAJANJE MENIJSKE VRSTICE V OBRAZEC

1. V elementu menija Igra ustvarite ekipo
Nova igra.
2. Za ukaz Nova igra bomo napisali
programsko kodo v prihodnje prek
nekaj korakov.

KORAK 3. DODAJANJE MENIJSKE VRSTICE V OBRAZEC

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

1. Z vlečenjem predmeta PictureBox na obrazec
spremenite njegovo velikost na 100x100.
2. Nastavite prozorno ozadje.
3. Namestite PictureBox, kot je prikazano v
slika nad prvo celico igralnega polja.

KORAK 4. DODAJANJE PICTUREBOX OBJEKTOV V OBRAZEC

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

1. Pred pisanjem kode
potrebno v mapi
\Visual Studio
2010\Projekti\Tic Tac Toe\X's
ničle\bin\Debug\ je treba ponovno zavrteti
datoteke x.png, 0.png, none.png iz mape Slike.
2. Dvokliknite z levo miško na prvo
PictureBox.

KORAK 5. DODAJANJE KODE ZA PICTUREBOX OBJEKTE

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

KORAK 5. DODAJANJE KODE ZA PICTUREBOX OBJEKTE

V postopku, ko kliknete na prvo
PictureBox, dodaj operator
izbira
ki
volja
preveri status
matrične celice. Če vrednost
celice polja bodo enake 0, kar
to pomeni, da ne obstaja niti "nič" niti
»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 v njem je zapisana 0, in
Prikaže se prazna celica.

KORAK 5. DODAJANJE KODE ZA PICTUREBOX OBJEKTE

1
2
3
4
5
6
7
8
9

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

V postopku, ko kliknete na gumb
dodati
operater
cikel
ki preverja
vse celice od prve do
prisotnost praznih celic. In če
celica je prazna,
potem vanjo
je zapisano »ničla« in sicer v
celica polja je zapisana -1.
Za udobje pri prihodnjem delu
spremenljivke
JAZ,
j
ki
uporablja za ponavljanje zank
Za celoten obrazec bomo objavili.

KORAK 6. DODAJANJE KODE ZA GUMB HOJA

Za prikaz ničel na
igranje
polje
potrebno
dodajte programsko kodo telesu
cikel preverjanja praznih celic.
Uporaba ugnezdenega stavka
razvejanje
volja
odvijati se
analiza naslova celice polja za
izpis ničle v pravilnem
PictureBox.
Dodamo tudi izjavo o prekinitvi
za predčasni konec
zanke, ko najde prazen
celice.

KORAK 6. DODAJANJE KODE 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 »Vaš
premakniti."
Za
to
ustvarjajmo
spremenljivka
odgovor
ki
Dodelimo ta stavek. A
pri nalaganju spremenljivke obrazca
mora biti dodeljen elementu
Label1, da ustvarite potrebno
postopkov
potrebno
najprej dvakrat kliknite
glede na obliko

KORAK 7. DODAJANJE PROGRAMSKE KODE ZA NOVO POSTAVKO MENIJA IGRE

Ko pritisnete ukaz novo
igra se bo ponastavila
vse celice matrike, zamenjava vseh
"križe" in "prste" na
prazne celice. Tudi zaključek
Znaki "Tvoja poteza".

KORAK 8. IZPISI REZULTAT 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
napredek
računalnik,
A
preverite
poraz po.
Zadnji ukaz postopka
rezultati bodo prikazani na zaslonu
napredek.

KORAK 8. IZPISI REZULTAT 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;

9. KORAK IZBOLJŠANJE IGRALNOSTI

Za izboljšanje igralnosti
namesto serijskega izhoda
do prvih praznih
celice "ničel", izvajamo
izhod prek naključnega generatorja
številke.
Če želite to narediti, 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 v disciplini

Osnove programiranja in algoritma

"Križci in krožci"

Dokončanoštudent skupine EM-21

Butorova L.Yu.

Sprejeto Rzheutskaya S. Yu.

UVOD

1. ANALIZA PROBLEMA IN DOLOČITEV ZAHTEV ZA PROGRAM, KI SE RAZVIJA

1 Namen programa, njegovi uporabniki, glavne funkcije in cilji, zasledovani med razvojem

2 Pregled dobro znanih programov, ki opravljajo podobne funkcije

3 Teoretične osnove razvoja

4 Izbira razvojnih orodij

PROJEKTIRANJE DEL RAZVOJA

1 Razvoj uporabniškega vmesnika

2.2 Razvoj podatkovnih struktur (v zunanjem in RAM)

2.3 Razvoj in analiza algoritmov

IZVEDBA PROGRAMA V JEZIKU C++

1 Arhitektura programa

2 Izbor standardnih vizualnih in nevizualnih komponent

REZULTATI TESTOV

ZAKLJUČEK

Bibliografija

Aplikacije

UVOD

Tic-tac-toe je 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 - s "prsti na nogah". Ta igra je postala priljubljena že dolgo pred pojavom računalnikov, šele preden so jo začeli igrati z navadnim kosom papirja in pisalom. Tradicionalna kitajska igra uporablja črne in bele kamne.

V tem tečajno delo Ohranjena so osnovna pravila in standardna velikost igralnega polja (3x3 celice). Zaradi udobja igre je pravica do prve poteze prepuščena uporabniku, to je "križcem".

Tic Tac Toe je program, ki je zasnovan tako, da zabava uporabnika, zato je njegov vmesnik v tem tečaju izdelan v igralnem slogu s kombinacijo pozitivnih barv, ki povečujejo čustveni del procesa igre.

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". Dobitki so fiksni, če so navpične, vodoravne ali diagonalne črte popolnoma zapolnjene s križci ali ničlami.

Če je prostih celic polja konec, vendar nihče ne zmaga, se šteje, da se je igra končala z "remijem".

1. ANALIZA PROBLEMA IN DOLOČITEV ZAHTEV ZA PROGRAM, KI SE RAZVIJA

programski navzkrižni vmesnik

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

Namen tega programa je predvsem zabavati uporabnike, popestriti čakanje osebe, saj vsako delo zahteva počitek, ta preprosta igra pa vam bo pomagala, da se sprostite in odvrnete misli od vsakdanjih zadev. "Tic Tac Toe" prav tako spada v razred intelektualnih in logičnih iger, ki so zasnovane za urjenje logičnega razmišljanja, vam omogočajo koncentracijo pozornosti in razvoj spomina.

Ciljna publika uporabnikov so otroci in najstniki ter odrasli. Glavna merila za uporabo izdelka sta zmožnost branja besedila, napisanega 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 človekovega logičnega potenciala.

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. Primer takšnih programov sta "Tic-tac-toe na neskončnem polju" in "Tic-tac-toe 3D". Tudi v mnogih igrah so "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 namenjena tako enemu uporabniku, katerega nasprotnik je umetna inteligenca (oz. računalnik), kot tudi dvema uporabnikoma. Predstavljena 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.

3D tic-tac-toe je veliko bolj zanimiv kot na papirju ali na navadni tabli. Več je priložnosti za zmago in poraz, remiji pa so redkejši. Igrate lahko sami - proti računalniku - ali skupaj s prijateljem. In najbolj nenavadna stvar tukaj je, da lahko za zmago sestavite kombinacijo treh kroglic svoje barve (črne ali bele) ne le na kateri koli ravni, temveč tudi vzdolž ravnine sten in celo diagonalno čez celotno polje ( Slika 1.1).

riž. 1.1

Med široko paleto iger na podobno temo lahko v vsakem delu izpostavimo edinstveno izvedbo načrta. Vsak projekt se od drugih razlikuje po svoji individualnosti.

1.3 Teoretične osnove razvoja

Analiza

Za vsako od strank obstajajo dobro znani algoritmi, ki zagotavljajo neodločen izid v kateri koli nasprotnikovi igri, in če njegov nasprotnik naredi napako, mu 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 "križce" gre prvi in deluje po zgornjem algoritmu, igralec za "prste" pa lahko dela kar hoče (in eno oglišče je podana za racionalno in za iracionalno dejanje, torej vsako drugo), je sestavljena iz 50 vozlišč.

1.4 Izbira razvojnih orodij

Za dosego naših ciljev potrebujemo integrirano okolje za razvoj aplikacij. Zato je razvoj projekta potekal v programskem okolju Microsoft Visual Studio 2008.

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

2. PROJEKTIRANJE DEL RAZVOJA

2.1 Razvoj uporabniškega vmesnika

Pri ustvarjanju igralne aplikacije je treba upoštevati eno od glavnih komponent uspeha izdelka - 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 se uporabniku pridruži igričarskemu vzdušju, zato je vmesnik zasnovan 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, kamor 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 dal sporočilo o tem, 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 tekme.

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 igre, morate nastaviti statično matriko gcnew array (9); v kateri bodo shranjena stanja igralnega polja, kjer vsaka celica matrike ustreza celici. "0" - ustreza prazni celici, če se je igralec premaknil 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 polja enaki "0". Potrebno je nastaviti statično spremenljivko lvl, ki shranjuje podatke o ravni. V tej igri so skupaj 3 stopnje: 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. stopnja z računalnikom” " Spremenljivka igralec shrani vrstni red (»true« je na vrsti igralec, »false« je na vrsti računalnik). Ker je pravica do prve poteze dana 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 iteracijo parametrov matrike x in podati lastno rešitev, ki bo optimalna za nadaljnje igranje. Ta program ima 2 ravni igranja z računalnikom. Na ravni 1 naloga računalnika ni premagati nasprotnika. Zato to funkcijo vrne naključno vrednost celice, kamor bo šel računalnik. Koda za ta algoritem 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), da preveri računalniško kombinacijo in, če obstaja možnost za dobitek, vrne številko celice. Če računalnik pri naslednji potezi ne more zmagati, se pokliče funkcija check(1): preverjanje igralčeve kombinacije. Številka celice, v kateri bi igralec zmagal, če bi se stava vrnila. Če takšne kombinacije ni, se pokliče funkcija low_level().

Slika 2.4. - Blok diagram

Slika 2.5. - Blok diagram

3. IZVEDBA PROGRAMA V JEZIKU 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 prikaže slikovno polje z rezultatom, skupaj jih je 5 (slika 2.3).

Za osnovo lahko uporabite upravljalnike klikov plošče, ki jih je na igrišču točno 9. Vsak upravljavec pokliče več funkcij. Na začetku je pogoj, če uporabnik izbere vrsto igre "X proti 0", se celice preprosto napolnijo z vrednostmi 1 ali 2 (križ ali nič). Sledijo funkcije: indikacija napredka (CrossZero()), ki spremeni križec v ničlo in obratno, blokiranje zasedenih celic checkingArray(), iskanje zmagovalca winner(). Funkcijawinner() upošteva vse možne zmagovalne možnosti, tako da če eden od igralcev postavi 3 svoje figure (križec ali ničlo) navpično, vodoravno ali diagonalno, bo zmagal. V nasprotnem primeru, če je polje polno, vendar se nobeden od igralcev ni postavil v vrsto, se pokliče funkcija (_friend()) za preverjanje izenačenja, ki preveri, ali so na polju še proste celice ali ne. Če je fr = true, potem na polju ni prostih celic. Če se je vrednost spremenila, to pomeni, da je na polju prosta celica.

Drugi pogoj deluje, če je izbrana druga ali tretja vrsta igre. Nato se imenuje funkcija, v kateri je bil računalnik premaknjen: premakni(int n). Posreduje številko celice, na katero je igralec kliknil. Sledijo funkcije: prikaz napredka (CrossZero()), blokiranje zasedenih celic checkingArray(). Nato se pokliče funkcija winner(), ki preveri, ali je igralec s to potezo zmagal ali ne. Če ne, se preveri prisotnost prostih celic. Če so proste celice, se računalnik premakne. Nato se glede na to, katero raven je izbral igralec "1" ali "2", pokličejo naslednje funkcije: low_level(), dif_level(). Funkcija low_level() naključno izbere, kam naj postavi ničlo, funkcija dif_level() pa predstavlja poseben algoritem za zmago računalnika. Sledijo funkcije: prikaz napredka (CrossZero()), blokiranje zasedenih celic checkingArray(). Nato se pokliče funkcija winner(), ki preveri, ali je računalnik s 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 Besedilo=Tic-Tac-Toe, ControlBox=False

2) f2, z navedenimi parametri BackColor, Text=Game

) comboBox1 z navedenimi parametri Items:

X proti 0

1. stopnja z računalnikom

2. stopnja z računalnikom

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

5) gumb z določenimi parametri Font, Fore Color, BackColor, Text, za vse gumbe so bili zapisani dogodki, kot je Click.

6) nalepka z določenimi parametri BackColor, Font, Fore Color, Text.

) pictureBox, z določenimi parametri Image, SizeMode= StretchImage.

) textBox, z določenimi 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 "Raven 1 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žne tudi druge možnosti za razvoj dogodkov.

Slika 4.3.

Vrsta igre: "Raven 2 z računalnikom". Na tej stopnji igra analizira vse poteze in poskuša izbrati najbolj optimalno potezo. Tudi tukaj možni vsi trije scenariji, saj Računalnik se prvič premakne v katero koli prosto celico. Najpogosteje se igra izenači.

Slika 4.4.

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

ZAKLJUČEK

Z gotovostjo lahko rečemo, da je naloga, zastavljena na začetku dela, opravljena. Med razvojem je bil načrtovan in razvit projekt za remix znane igre "Tic Tac Toe". Igra izpolnjuje navedene zahteve in izpolnjuje 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 utrjeno. 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;

Enostaven za uporabo;

Precej jasen uporabniški priročnik;

Brez nepotrebnih 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 lahkega 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žav sovražnik

//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 preverjanja, ali je v celici nekaj, če je, potem ne morete več klikniti te celice. (x == 1) (panel1->BackgroundImage = panel11->BackgroundImage ;panel1- >Omogočeno = false;)(x == 2) (panel1->BackgroundImage = panel10->BackgroundImage;panel1->Enabled = false;)(x == 1) (panel2->BackgroundImage = panel11->BackgroundImage ;panel2- >Omogočeno = false;)(x == 2) (panel2->BackgroundImage = panel10->BackgroundImage;panel2->Enabled = false;)(x == 1) (panel3->BackgroundImage = panel11->BackgroundImage ;panel3- >Omogočeno = false;)(x == 2) (panel3->BackgroundImage = panel10->BackgroundImage;panel3->Enabled = false;)(x == 1) (panel4->BackgroundImage = panel11->BackgroundImage ;panel4- >Omogočeno = false;)(x == 2) (panel4->BackgroundImage = panel10->BackgroundImage;panel4->Enabled = false;)(x == 1) (panel5->BackgroundImage = panel11->BackgroundImage ;panel5- >Omogočeno = false;)(x == 2) (panel5->BackgroundImage = panel10->BackgroundImage;panel5->Enabled = false;)(x == 1) (panel6->BackgroundImage = panel11->BackgroundImage ;panel6- >Omogočeno = false;)(x == 2) (panel6->BackgroundImage = panel10->BackgroundImage;panel6->Enabled = false;)(x == 1) (panel7->BackgroundImage = panel11->BackgroundImage ;panel7- >Omogočeno = false;)(x == 2) (panel7->BackgroundImage = panel10->BackgroundImage;panel7->Enabled = false;)(x == 1) (panel8->BackgroundImage = panel11->BackgroundImage ;panel8- >Omogočeno = false;)(x == 2) (panel8->BackgroundImage = panel10->BackgroundImage;panel8->Enabled = false;)(x == 1) (panel9->BackgroundImage = panel11->BackgroundImage ;panel9- >Omogočeno = false;)(x == 2) (panel9->BackgroundImage = panel10->BackgroundImage;panel9->Enabled = false;)

): bool zmagovalec())(// preverjanje zmagovalca in blokiranje vseh preostalih celic.

//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;-> Enabled = false;->Enabled = false;->Enabled = false;->Enabled = false;true;

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

): 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 == "1. stopnja z računalnikom") lvl = 2; (typeGame == "2. stopnja z računalnikom") lvl = 3;( ); = res; (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;();();();