itthon › Telepítés és konfiguráció › Tic-tac-toe játék készítése. A fejlesztés elméleti alapjai

Tic-tac-toe játék készítése. A fejlesztés elméleti alapjai

Üdvözlet, kedves barátaim! Ebben a leckében megmutatom, hogyan készíthetsz böngészős játékot - tic-tac-toe, javascriptben! Mindenki tudja, mi ez a játék és hogyan kell játszani vele, de hadd emlékeztesselek még egyszer:

A Tic-tac-toe egy logikai játék két játékos között egy 3 x 3 cellás (esetleg nagyobb) mezőn. Az egyik a „keresztekkel”, a másik a „lábujjakkal” játszik.

P.S. mint minden hasonló javascript leckében, a cikk végén letöltheti a forrásfájlt, és a munka eredményét egy demópéldán is megtekintheti!

A készülő játék leírása

Nézzük a játék jellemzőit:

a játék az oldal betöltése után azonnal elindul;
az első lépés jogát véletlenszerűen választják ki (akár elindul, akár a számítógép);
a fogadni kívánt jelet véletlenszerűen választják ki (kereszt vagy nulla);
ha a játékos nyer, a nyerő szimbólumok (kereszt vagy nulla csík) zöld színnel vannak kiemelve;
ha a játékos veszít a számítógép ellen, a sáv piros színnel van kiemelve;
A mező felett van egy információs sor, ahol megjelenik az eredmény (győzelem vagy vereség).

Logikák

Nem találtam ki bonyolult (univerzális) algoritmusokat a 3:3 négyzetes játéktérhez, hanem a másik irányba mentem - a nyers erő! (erről kicsit később). Három fő egymást követő szakaszt azonosítottam, amelyeken minden logika nyugszik:

1. szakasz: annak ellenőrzése, hogy a játékos nyert-e?

Ebben a szakaszban ellenőrizzük, hogy van-e 3 cella (ugyanazon a sorban), amelyek ugyanazokkal a játékosszimbólumokkal (keresztekkel vagy nullákkal) vannak kitöltve. Azok. függetlenül attól, hogy mi a lépés (még az első is), először mindig ellenőrizzük, hogy a játékos nyert-e. Így néz ki a győzelem:

2. szakasz: ellenőrzés – nyerhet-e a számítógép a következő lépéssel?

Ebben a szakaszban egy olyan sort keresünk, ahol 2 számítógép által kitöltött cella és egy üres cella lenne - vagyis a játékos figyelmetlensége miatt próbálunk nyerni. Így néz ki a vereség (azaz számítógépes győzelem):

3. szakasz: nem hagyjuk, hogy nyerj!

Itt ugyanazt a sort keressük, mint a második szakaszban, csak 2 cellát kell kitölteni a játékos játékjeleivel, vagyis ebben a szakaszban nem engedjük, hogy a számítógép veszítsen egy üres cellába való jel elhelyezésével. Mindegyik szakasz egy független funkciót képvisel – ezt az alábbi js kódban láthatja.

Végrehajtás

A játéktér elrendezése nagyon egyszerű - a fő blokk egy információsort (osztály - eredmény) és 9 blokkot tartalmaz, amelyek cellák (osztály - blokk) A cellák HTML-elrendezése:

Te jössz!

A segédosztály cellája szükséges a kívánt cella pontos azonosításához a játéktéren. CSS stílusok a játéktérhez:

Krestiki_noliki(szélesség: 306px; margó: 0 auto; ) .krestiki_noliki .block(szélesség: 100px; magasság: 100px; szegély: 1px tömör #cc; kurzor: mutató; lebegés: balra; szövegigazítás: középen; betűméret: 100 képpont; sor magassága: 94 képpont; )

Most nézzük meg a teljes JS-kódot, majd a főbb pontokról beszélek:

$(dokumentum).ready(function())( var znak_user = "O"; var znak_comp = "X"; var rand_num = Math.round((Math.random() * (9 - 1) + 1)); if (rand_szám > 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"]; //Határozza meg a játékos győzelmi függvényét 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; } }); });

Először deklaráljuk a változókat: znak_user - ebben a változóban tároljuk azt a jelet, amellyel a felhasználó játszani fog (alapértelmezés szerint egy nulla van tárolva - ez az angol "O" mező). znak_comp - ebben a változóban tároljuk azt a jelet, amellyel a számítógép játszani fog (alapértelmezés szerint egy kereszt van ott tárolva - ez az angol "X" mező).

A logika a következő: ha a véletlenszám nagyobb, mint 3, akkor a számítógép nullákkal játszik, és ő (a számítógép) teszi meg az első lépést.

Ezt a logikát az Ön számára kényelmesen módosíthatja, például létrehozhat több véletlenszerű számot annak érdekében, hogy több lehetőséget adjon arra, hogy ki lesz az első, és milyen előjelekkel. exit_flag - ez a jelző (változó) felelős a funkcióból való kilépésért, azaz például amikor a számítógép már megtette a lépését, és ki kell lépnie a funkcióból, és át kell adnia a lépést a lejátszónak. win_user_array - ez a tömb tárolja az összes nyerő opciót a cellák kitöltéséhez. Hogy érthetőbb legyen, nézzük meg ezt a képet:

A tömb minden eleme egy három számból álló karakterlánc, ami nyerő kombináció, vagyis ha például kitöltöd az 1-es, 2-es és 3-as szám alatti cellákat, akkor győzelem (vagy vereség) következik be. Amint látja, összesen 8 nyerési lehetőség van, a mi feladatunk az, hogy ezeket az opciókat végignézzük. Következzen 3 funkció:

check_3_user();
check_2_comp();
check_2_user();

Ezeknek a függvényeknek a célját (három lépésben) a Logika részben (fent) ismertetjük. Ezeket a függvényeket a mező bármelyik cellájára kattintva hívhatja meg. Minden funkcióhoz egy paraméter (znak) kerül átadásra - ez a játékos vagy a számítógép jele (kereszt vagy nulla), például a játékos győzelmét meghatározó függvénynek (check_3_user), sorrendben adjuk át a játékos jelét. hogy 3 egyforma jelet találjunk ugyanazon a sorban.

Három funkció után (ha a számítógép még nem mozdult meg) a számítógép kitölti az egyik szabad cellát. Itt bonyolíthatja a játékmenetet, például úgy, hogy ha a központi cella szabad (5-ös számú cella), akkor először fogadjon benne, ha foglalt, akkor fogadjon az egyik szabad sarokba (ezek a 1., 3., 7. és 9. számú cellák) és így tovább – itt általában az Ön belátása szerint dönt.

Elvileg ennyi kell egy ilyen játék létrehozásához.

Most megnézheti a játékot egy demo példa segítségével, és letöltheti a forrásfájlt (összesen 1 fájl).

2018.08.06 - köszönjük a figyelmet a levél írójának: Patvakan Baghdasaryannak, egy hibát javítottak, amikor a számítógépen több lehetséges opciók a győzelmeket és az összes nyerő lépését lefestették (3 helyett 4-ről 6 cellára).

Nekem ennyi, remélem hasznos volt számodra ez a lecke, sok sikert kívánok, viszlát!

Hogyan írjunk egy botot, amelyet nem lehet legyőzni tic-tac-toe-val, vagy Bevezetés a minimax szabályba

Lehetséges, hogy több száz tic-tac-toe játék után azon töprengtél: mi az optimális algoritmus? De ha itt vagy, akkor valószínűleg megpróbáltad írni ennek a játéknak a megvalósítását. Tovább megyünk, és írunk egy botot, amelyet lehetetlen lesz legyőzni. Megelőlegezve a „miért?” kérdését, azt válaszoljuk: az algoritmusnak köszönhetően.

Mint egy profi sakkozó, ez az algoritmus több lépéssel előre kiszámítja az ellenfél akcióit – egészen a játszma végéig, legyen szó győzelemről, vereségről vagy döntetlenről. Ha ebben a végső állapotban van, az AI pozitív pontszámot (esetünkben +10) ad magának a győzelemért, negatív (-10) a vereségért, és semleges (0) a döntetlenért.

Ugyanakkor az algoritmus hasonló számításokat végez a játékos lépéseire. A legmagasabb pontszámot elérő lépést választja, ha az AI mozog, és a legalacsonyabb lépést, ha a játékos mozog. Ezzel a stratégiával a minimax elkerüli a vereséget.

Próbáld meg játszani ezt a játékot.

A minimax algoritmus legegyszerűbben rekurzív függvényként írható le, amely:

értéket ad vissza, ha a végső állapot megtalálható (+10, 0, -10),
átmegy az összes üres cellán a mezőn,
mindegyikhez meghívja a minimax függvényt (rekurzió),
kiértékeli a kapott értékeket
és a legjobbat adja vissza.

Ha nem ismeri a rekurziót, akkor nézze meg ezt az előadást a Harvard CS50 tanfolyamról:

A minimax működésének megértéséhez írjuk le a megvalósítását és modellezzük a viselkedését. Ezzel a következő két részben foglalkozunk.

Minimax megvalósítás

Megvizsgálunk egy olyan helyzetet, amikor a játék a végéhez közeledik (lásd az alábbi képet). Mivel a minimax az összes lehetséges játékállapoton keresztül megy (és több százezer van belőlük), érdemes a végjátékot figyelembe venni – így kevesebb rekurzív függvényhívást kell követnünk (összesen 9-et).

Hagyja, hogy az AI játsszon keresztekkel, az ember pedig nullákkal.

A mezővel való munka megkönnyítése érdekében deklaráljuk 9 elemből álló tömbként, amelyek értéke megegyezik a cellák tartalmával. Töltsük meg keresztekkel és lábujjakkal, mint a fenti képen, és nevezzük origBoardnak.

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

Ezután deklaráljuk az aiPlayer és a huPlayer változókat, és hozzárendeljük az „X” és „O” értékeket.

Ezen kívül szükségünk lesz egy függvényre, amely a nyerő kombinációkat keresi, és a keresés sikeressége esetén valódi értéket ad vissza, valamint egy olyan függvényre, amely eltárolja az elérhető cellák indexeit.

/* kezdeti állapot táblák O | | X --------- X | | X --------- | O | O */ var origBoard = [“O”,1 ,”X”,”X”,4 ,”X”, 6 ,”O”,”O”]; // személy var huPlayer = “O”; // AI var aiPlayer = “X”; // visszaadja a tábla üres celláinak indexeit indexek függvény nyerő(tábla, játékos)( if((tábla == játékos && tábla == játékos && tábla == játékos) || (tábla == játékos && tábla == játékos && tábla == játékos) || (tábla == játékos) = játékos && tábla == játékos && tábla == játékos) || (tábla == játékos && tábla == játékos && tábla == játékos) || (tábla == játékos && tábla == játékos && tábla == játékos) || | (tábla == játékos && tábla == játékos && tábla == játékos) || (tábla == játékos && tábla == játékos && tábla == játékos) || (tábla == játékos && tábla == játékos && tábla == = játékos)) ( igazat ad vissza; ) else ( hamis értéket ad vissza; ) )

Tehát definiáljunk egy minimax függvényt két argumentummal: newBoard és player. Ezután megkeressük a szabad cellák indexeit a mezőn, és átadjuk az availSpots változónak.

// fő minimax függvény függvény minimax(newBoard, player)( // elérhető cellák var availSpots = emptyIndices(newBoard);

Ezenkívül nyomon kell követnünk a végső állapotokat, és vissza kell adnunk a megfelelő értékeket. Ha a „nulla” nyer, akkor -10-et kell visszaadnia, ha a „kereszt” - +10. Ha az availSpots tömb mérete nulla, akkor nincsenek szabad cellák, a játék döntetlen lesz, és nullát kell visszaadni.

// a terminál állapotának ellenőrzése (win/loss/draw) //és ennek megfelelő érték visszaadása if (winness(newBoard, huPlayer))( return (pontszám:-10); ) else if (winer(newBoard, aiPlayer)) ( return (pontszám:10); ) else if (availSpots.length === 0)( return (pontszám:0); )

Ezt követően minden üres cellából pontokat kell gyűjteni. Ehhez létrehozunk egy mozgástömböt, és egy ciklusban végigmegyünk az összes üres cellán, elhelyezve az egyes lépések indexeit és pontjait a mozgatási objektumban.

Ezután az origBoardban számként tárolt üres cella indexét a mozgatható objektum index tulajdonságával egyenlőnek állítjuk be. Ezután az aktuális játékosként átmegyünk az új newBoard mező üres cellájába, és meghívjuk a másik játékostól a minimax függvényt és a kapott newBoard mezőt. Ezt követően a minimax függvény által visszaadott objektum score tulajdonságát kell beírni a mozgatható objektum score tulajdonságába.

Ha a minimax nem talál terminális állapotot, akkor továbbra is rekurzív módon halad a játék mélyére, amíg el nem éri a terminális állapotot. Ezt követően a rekurzió ezen „szintjének” pontjait egy szinttel feljebb helyezi át.

Végül a függvény visszaállítja a newBoard módosításait, és a mozgatási objektumot a mozgatási tömbbe helyezi.

// tömb az összes objektum tárolására var moves = ; // hurok a rendelkezésre álló cellák között (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); }

A Minimax-nak ezután ki kell választania a legjobb lépést a mozgástömbből. A legmagasabb pontszámú lépésre van szüksége, ha az AI mozog, és a legalacsonyabbra, ha emberi lépésről van szó. Így, ha a játékos értéke aiPlayer , akkor az algoritmus nagyon kis számra inicializálja a bestScore változót, és végigfut a lépések tömbjén: ha egy lépés pontszáma többet ér, mint a bestScore , akkor az algoritmus megjegyzi ezt a lépést . Egyenlő pontú lépések esetén az algoritmus megjegyzi az elsőt.

Abban az esetben, ha a játékos egyenlő a huPlayerrel, minden hasonló - csak most a bestScore nagy számra inicializálódik, és a minimax a legkevesebb pontot kapó lépést keresi.

Ennek eredményeként a minimax visszaadja a bestMove-ban tárolt objektumot.

// ha ez egy mesterséges intelligencia lépés, görgessen végig a lépéseken, és válassza ki a legtöbb pontot tartalmazó lépést var bestMove; if(player === aiPlayer)( var bestScore = -10000; for(var i = 0; i< moves.length; i++){ if(moves[i].score >bestScore)( bestScore = mozog[i].score; bestMove = i; ) ) )else( // ellenkező esetben ismételje meg a mozdulatokat, és válassza ki a legkevesebb pontot tartalmazó lépést var bestScore = 10000; for(var i = 0; i< moves.length; i++){ if(moves[i].score < bestScore){ bestScore = moves[i].score; bestMove = i; } } } // вернуть выбранный ход (объект) из массива ходов return moves; }

A következő részben szimuláljuk a programunkat, hogy megértsük, hogyan működik.

Minimax működés közben

Az alábbi diagram segítségével elemezzük az algoritmus lépésenkénti modelljét.

jegyzet: A diagramon a nagy számok a függvényhívás sorozatszámát, a szintek pedig azt, hogy az algoritmus hány lépést tett előre.

Az origBoard és az aiPlayer betáplálva van az algoritmusba. Listát készít a talált három üres celláról, ellenőrzi az állapot végességét, és végigfut az összes üres cellán. Az algoritmus ezután megváltoztatja a newBoard értéket, és az aiPlayert az első üres mezőbe helyezi. Ezt követően meghívja magát a newBoardból és a huPlayerből, és várja a második hívást, hogy visszaadjon egy értéket.
Amíg az első függvényhívás még fut, a második lefut, létrehoz egy listát két üres cellából, ellenőrzi a véges állapotot, és végigfut az összes üres cellán. A második hívás ezután módosítja a newBoard-ot úgy, hogy a huPlayert az első üres mezőbe helyezi. Ezt követően meghívja magát a newBoardból és az aiPlayerből, és várja a harmadik hívást, hogy visszaadjon egy értéket.
Mivel a második hívás két üres cellát talált, a minimax úgy módosítja a newBoardot, hogy a huPlayert a második üres cellába helyezi. Ezután meghívja magát a newBoard-ból és az aiPlayer-ből.
Az algoritmus összeállítja az üres cellák listáját, és az állapot végességének ellenőrzése után rögzíti a játékos győzelmét. Tehát egy (-10) pontmezővel rendelkező objektumot ad vissza.
A második függvényhívásban az algoritmus megkapja a harmadik és negyedik függvényhívás által az alsó szintről visszaadott értékeket. Mivel a huPlayer lépése ezt a két eredményt hozta, az algoritmus a kisebbet választja. Mivel ugyanazok, az algoritmus kiválasztja az elsőt, és átadja az első függvényhívásnak.

Ezen a ponton az első függvényhívás becslést kapott az aiPlayer első üres cellába való költözéséről. Ezután módosítja a newBoard-ot úgy, hogy az aiPlayert a második üres mezőbe helyezi. Utána a newBoard-ról és a huPlayer-ről hívja magát.
Az ötödik függvényhívásban az algoritmus összeállítja az üres cellák listáját, és az állapot végességének ellenőrzése után rögzíti az AI győzelmét. Tehát egy +10-es pontszámmezővel rendelkező objektumot ad vissza.
Ezt követően az első hívás módosítja a newBoard-ot úgy, hogy az aiPlayert a harmadik üres cellába helyezi. Ezután a newBoard-ból és a huPlayer-ből hívja magát.
A hatodik hívás listát készít két üres cellából, ellenőrzi az állapot végességét, és végigfut az összes üres cellán. Ezután módosítja a newBoard-ot úgy, hogy a huPlayert az első üres mezőbe helyezi. Ezután meghívja magát a newBoardból és az aiPlayerből, és várja a hetedik hívást, hogy visszaadjon egy értéket.
Az új hívás létrehoz egy listát egy üres cellából, ellenőrzi a véges állapotot, és módosítja a newBoard-ot, hogy az aiPlayert az üres cellába helyezze. Ezt követően meghívja magát a newBoardból és a huPlayerből, és várja, hogy ez a hívás visszaadjon egy értéket.
A nyolcadik kihívás az üres listaüres cellákat, és rögzíti az aiPlayer győzelmét a végtag állapotának ellenőrzése után. Ezért egy (+10) számlálómezővel rendelkező objektumot ad vissza a fenti szintre, a hetedik hívásra.
A hetedik hívás csak egy, pozitív értéket kapott az alsóbb szintekről. Mivel ezt az értéket az aiPlayer köre során kaptuk, az algoritmus a legnagyobb kapott értéket adja vissza. Tehát pozitív értéket (+10) ad vissza a szinttel feljebb, a hatodik hívásra.

Mivel a hatodik hívás két üres cellát talált, a minimax úgy módosítja a newBoard-ot, hogy a huPlayert a második üres cellába helyezi. Ezután meghívja magát a newBoard-ból és az aiPlayer-ből.
Ezt követően az algoritmus összeállítja az üres cellák listáját, és az állapot végességének ellenőrzése után rögzíti az aiPlayer győzelmét. Ezért egy (+10) pontmezővel rendelkező objektumot ad vissza a fenti szintre.
Ezen a ponton a hatodik kihívásnak választania kell a hetedik kihívás által adott pontszám (+10) és a kilencedik kihívás által adott pontszám (-10) között. Mivel a huPlayer lépése ezt a két eredményt hozta, az algoritmus kiválasztja a kisebbet, és azt pontszám- és indexmezőkkel rendelkező objektumként visszahelyezi a következő szintre.

Végül az első hívás mindhárom ága kiértékelésre kerül (-10, +10, -10). Mivel az aiPlayer lépése ezt a három eredményt hozta, az algoritmus kiválasztja a legtöbb pontot tartalmazó objektumot (+10) és indexét (4).

A fenti forgatókönyvben a minimax dönt erről optimális választás költözés lesz a pálya központi terére.

Vége!

Mostanra meg kellett értenie a minimax algoritmus működését. Próbáljon meg saját maga megírni egy megvalósítást, vagy nézzen meg egy példát a GitHubon vagy a CodePen-en, és optimalizálja azt.

Ha érdekli az AI a játékokban témája, javasoljuk, hogy olvassa el a témával kapcsolatos anyagainkat.

1. LÉPÉS. AZ ŰRLAP PARAMÉTEREK KONFIGURÁLÁSA1. Egy űrlap testreszabásához állítsa be a méretét
510 pont vízszintesen és 480 pont vízszintesen
függőleges. Maximum és minimum
jelölje meg az azonos értékekkel megegyező méretet.
2. Nevezze el az alakzatot „Tic Tac Toe”.
3. Az űrlap hátteréhez használjon egy fájlt a mappából
Képeket a background.png név alatt, és helyezze el
az űrlap közepén.
4. Egy ikonhoz a címsorban
használja a mappából származó fájl használatát
Képek a menu4.ico név alatt.
5. Az űrlap háttérszínét be kell állítani
MintCream.

2. LÉPÉS: GOMB ÉS CÍMKE HOZZÁADÁSA AZ ŰRLAPHOZ

1. Az elhelyezett elemeknél módosítsa
betűméret 12-re és a háttér beállítása
átlátszó.

1. Hozzon létre egy menüsort az elemekkel
a képen látható módon.

3. LÉPÉS. MENÜSÁR HOZZÁADÁSA AZ ŰRLAPHOZ

1. A Fájl menüpontban hozzon létre egy parancsot
Kijárat.
2. Mert
csapatok
Kijárat
írjunk elő
a program kódja ugyanaz, mint benne
korábbi jelentkezés.

3. LÉPÉS. MENÜSÁR HOZZÁADÁSA AZ ŰRLAPHOZ

1. A Játék menüpontban hozz létre egy csapatot
Egy új játék.
2. Az Új játék parancshoz írunk
programkódot a jövőben keresztül
néhány lépést.

3. LÉPÉS. MENÜSÁR HOZZÁADÁSA AZ ŰRLAPHOZ

1. A Súgó menüpontban hozzon létre egy parancsot
A programról.
2. Az About the program parancshoz hozzon létre egy újat
formázzuk ki és írjuk be a programkódot
hasonló, mint az előzőben
Alkalmazás.

1. PictureBox objektum ráhúzásával az űrlapra
módosítsa a méretét 100x100-ra.
2. Állítson be egy átlátszó hátteret.
3. Helyezze el a PictureBox-ot az ábrán látható módon
kép a játékmező első cellája felett.

4. LÉPÉS: PICTUREBOX OBJEKTUMOK HOZZÁADÁSA AZ ŰRLAPHOZ

1
2
3
4
5
6
7
8
9
1. A fennmaradó cellák fölé helyezzük
PictureBox objektumok, az első másolatai
pontján feltüntetett számozás szerint
Képek.

1. Mielőtt kódot írna
szükséges a mappában
\Vizuális Stúdió
2010\Projects\Tic Tac Toe\X's
a nullákat\bin\Debug\ újra kell görgetni
x.png, 0.png, none.png fájlokat a Képek mappából.
2. Kattintson duplán a bal egérgombbal az elsőre
PictureBox.

5. LÉPÉS. KÓD HOZZÁADÁSA A PICTUREBOX OBJEKTUMOKHOZ

1. Hozzon létre egy kétdimenziós tömböt, amely az összes elem számára elérhető
egész számokból álló 3x3-as elemek formájában készült. Azonnal
deklarálásakor nullákkal töltjük fel. Az üres cellákért mi
0-t fogunk használni, a „keresztekhez” - 1, a „nullákhoz” pedig -1.

5. LÉPÉS. KÓD HOZZÁADÁSA A PICTUREBOX OBJEKTUMOKHOZ

Az eljárás során, amikor az elsőre kattint
PictureBox, adjon hozzá operátort
választás
melyik
akarat
ellenőrizd az állapotot
tömbsejtek. Ha az érték
tömb cellái egyenlőek lesznek 0-val, ami
ez azt jelenti, hogy nincs sem „nulla”, sem
„kereszt”, majd ebben a cellában
a tömb 1 és be van írva
Képdoboz 1
Megjelenik
„kereszt” képe, és ha
a tömbcella értéke lesz
egyenlő 1, akkor tartalmazza
„kereszt” és 0 van beleírva, és
Egy üres cella jelenik meg.

5. LÉPÉS. KÓD HOZZÁADÁSA A PICTUREBOX OBJEKTUMOKHOZ

1
2
3
4
5
6
7
8
9

A mező többi cellájához adja hozzá a kódot
ugyanaz, mint az elsőben, csak változik
PictureBox objektumszám és cellacím
sor.
PÉLDA a második cellára:

Abban az eljárásban, amikor egy gombra kattint
add hozzá
operátor
ciklus
aki ellenőrzi
minden cella az elsőtől kezdődően
üres sejtek jelenléte. És ha
üres a cella,
majd belé
„nulla” van írva, mégpedig in
a tömb cellája -1.
A későbbi munkák kényelme érdekében
változók
ÉN,
j
melyik
ciklusok iterálására használják
A teljes űrlapot meghirdetjük.

6. LÉPÉS. KÓD HOZZÁADÁSA A SÉTA GOMBHOZ

A nullák megjelenítéséhez
szerencsejáték
terület
szükséges
programkód hozzáadása a törzshöz
a cellák ürességének ellenőrzési ciklusa.
Beágyazott utasítás használata
elágazó
akarat
megtörténik
tömb cellacímének elemzése
nullát adjon ki helyesen
PictureBox.
Hozzáadunk egy break utasítást is
az idő előtti befejezéshez
hurok, amikor üres
sejteket.

6. LÉPÉS. KÓD HOZZÁADÁSA A SÉTA GOMBHOZ

A játék állapotának jelzésére
interfész elemet használnak
Címke1. Mivel a játékos mindig mozog
első
Hogy
nál nél
letöltések
alkalmazások
szükséges
V
elem
Címke1
szükséges
tükrözik
kifejezések „A tiéd
mozog."
Mert
ez
alkossunk
változó
válasz
melyik
Adjuk hozzá ezt a kifejezést. A
az űrlap betöltésekor egy változót
elemhez kell rendelni
Label1, a szükséges létrehozásához
eljárások
szükséges
először kattintson duplán
forma szerint

7. LÉPÉS: PROGRAMKÓD HOZZÁADÁSA AZ ÚJ JÁTÉK MENÜPONTHOZ

Ha megnyomja az új parancsot
a játék visszaáll
a tömb összes cellája, lecserélve az összeset
"kereszt" és "lábujjak" rá
üres cellák. A következtetést is
„A te lépésed” táblák

8. LÉPÉS KIADJA A JÁTÉK EREDMÉNYÉT

A mozdulatok eredményének ellenőrzésére
szükséges
elemezni
sorok, oszlopok tartalma és
Diagonal vonalok. Ha mindhárom elem
egyenlő 1-gyel, akkor ez a játékos győzelme, és
ha három -1 akkor ez vereség
játékos.
Győzelmi csekk szükséges
magatartás
előtt
előrehalad
számítógép,
A
jelölje be
vereség után.
Az eljárás utolsó parancsa
az eredmények megjelennek a képernyőn
előrehalad.

8. LÉPÉS KIADJA A JÁTÉK EREDMÉNYÉT

Programkód a felhasználó győzelmének ellenőrzéséhez:
if (znacheniyeYacheyki == 1 && znacheniyeYacheyki == 1 && znacheniyeYacheyki == 1) otvet = "Te nyersz";
if (znacheniyeYacheyki == 1 && znacheniyeYacheyki == 1 && znacheniyeYacheyki == 1) otvet = "Te nyersz";
if (znacheniyeYacheyki == 1 && znacheniyeYacheyki == 1 && znacheniyeYacheyki == 1) otvet = "Te nyersz";
if (znacheniyeYacheyki == 1 && znacheniyeYacheyki == 1 && znacheniyeYacheyki == 1) otvet = "Te nyersz";
if (znacheniyeYacheyki == 1 && znacheniyeYacheyki == 1 && znacheniyeYacheyki == 1) otvet = "Te nyersz";
if (znacheniyeYacheyki == 1 && znacheniyeYacheyki == 1 && znacheniyeYacheyki == 1) otvet = "Te nyersz";
if (znacheniyeYacheyki == 1 && znacheniyeYacheyki == 1 && znacheniyeYacheyki == 1) otvet = "Te nyersz";
if (znacheniyeYacheyki == 1 && znacheniyeYacheyki == 1 && znacheniyeYacheyki == 1) otvet = "Te nyersz";
Programkód a felhasználó győzelmének ellenőrzéséhez:
if (znacheniyeYacheyki == -1 & znacheniyeYacheyki == -1 & znacheniyeYacheyki == -1) otvet = "Elveszítettél";
if (znacheniyeYacheyki == -1 & znacheniyeYacheyki == -1 & znacheniyeYacheyki == -1) otvet = "Elveszítettél";
if (znacheniyeYacheyki == -1 & znacheniyeYacheyki == -1 & znacheniyeYacheyki == -1) otvet = "Elveszítettél";
if (znacheniyeYacheyki == -1 & znacheniyeYacheyki == -1 & znacheniyeYacheyki == -1) otvet = "Elveszítettél";
if (znacheniyeYacheyki == -1 & znacheniyeYacheyki == -1 & znacheniyeYacheyki == -1) otvet = "Elveszítettél";
if (znacheniyeYacheyki == -1 & znacheniyeYacheyki == -1 & znacheniyeYacheyki == -1) otvet = "Elveszítettél";
címke1.Szöveg = válasz;

9. LÉPÉS A JÁTSZHATÓSÁG JAVÍTÁSA

A játszhatóság javítása érdekében
soros kimenet helyett
az első üresekre
„nullák” celláit valósítjuk meg
kimenet véletlen generátoron keresztül
számok.
Ehhez hozzá kell adni
egy logikai változó
uslovie, és módosítsa a ciklus típusát For-ról
Amíg, mivel nem tudjuk
az ismétlések pontos száma
generátor véletlen számok Viszlát
nem fog egy üres cellába esni.

OROSZORSZÁG OKTATÁSI ÉS TUDOMÁNYOS MINISZTÉRIUMA

szövetségi állam költségvetési felsőoktatási intézménye

"Vologdai Állami Egyetem"

Automatizálási és Számítástechnikai Tanszék

Magyarázó megjegyzés a tantárgyi projekthez

Programozási és algoritmikus alapismeretek

"Tic Tac Toe"

Befejezve az EM-21 csoport tanulója

Butorova L.Yu.

Elfogadott Rzheutskaya S. Yu.

BEVEZETÉS

1. A PROBLÉMA ELEMZÉSE ÉS A KIALAKÍTANDÓ PROGRAM KÖVETELMÉNYEINEK MEGHATÁROZÁSA

1 A program célja, felhasználói, főbb funkciói és a fejlesztés során követett célok

2 Ismert, hasonló funkciókat ellátó programok áttekintése

3 A fejlesztés elméleti alapjai

4 Fejlesztőeszközök kiválasztása

TERVEZÉSI RÉSZ A FEJLESZTÉSBEN

1 Felhasználói felület fejlesztés

2.2 Adatstruktúrák fejlesztése (külső és RAM-ban)

2.3 Algoritmusok fejlesztése és elemzése

A PROGRAM MEGVALÓSÍTÁSA C++ NYELVEN

1 Program architektúra

2 Szabványos vizuális és nem vizuális komponensek kiválasztása

VIZSGÁLATI EREDMÉNYEK

KÖVETKEZTETÉS

Bibliográfia

Alkalmazások

BEVEZETÉS

A Tic-tac-toe egy logikai játék két ellenfél között egy 3 x 3 cellás vagy nagyobb négyzetmezőn (akár „végtelen mezőig”). Az egyik játékos „keresztekkel”, a második „lábujjakkal” játszik. Ez a játék már jóval a számítógépek megjelenése előtt népszerűvé vált, csak azelőtt, hogy normál papírral és tollal játszották volna. A hagyományos kínai játék fekete-fehér köveket használ.

Ebben tanfolyami munka Az alapvető szabályok és a játékmező szabványos mérete (3x3 cella) megmarad. A játék kényelme érdekében az első lépés megtételének jogát a felhasználóra bízzuk, azaz „kereszteket”.

A Tic Tac Toe egy olyan program, amely a felhasználó szórakoztatását szolgálja, ezért a felülete ebben a kurzusmunkában játékstílusban készült, pozitív színkombinációval, amely fokozza a játék folyamatának érzelmi részét.

Három típusa van a játékban: X versus 0 - felhasználó kontra felhasználó, „1. szint számítógéppel” - azoknak, akik csak a világjáték alapjait tanulják, és szint „2. szint számítógéppel” - azoknak, akik teljesen biztosak a győzelmükben. Az 1. és 2. szinten három lehetséges kimenetel lehetséges: „győzelem”, „vesztés” és „döntetlen”. A nyeremény fix, ha a függőleges, vízszintes vagy átlós vonalak teljesen tele vannak keresztekkel vagy nullákkal.

Ha a mező szabad cellái véget értek, de senki sem nyer, akkor a játék „döntetlen”-nek minősül.

1. A PROBLÉMA ELEMZÉSE ÉS A KIALAKÍTANDÓ PROGRAM KÖVETELMÉNYEINEK MEGHATÁROZÁSA

program kereszt interfész

1.1 A program célja, felhasználói, főbb funkciói és a fejlesztés során követett célok

Ennek a programnak mindenekelőtt a felhasználók szórakoztatása, az ember várakozási idejének felvillanyozása a célja, mert minden munka pihenést igényel, ez az egyszerű játék pedig segít kikapcsolódni és elterelni a gondolatait a mindennapi ügyekről. A „Tic Tac Toe” szintén az intellektuális és logikai játékok osztályába tartozik, amelyek célja a logikus gondolkodás képzése, lehetővé teszi a figyelem összpontosítását és a memória fejlesztését.

A felhasználók célközönsége gyerekek és tinédzserek, valamint felnőttek. A termék használatának fő kritériuma a programban írt szöveg olvasásának képessége, valamint a számítógép számára szükséges feladat kiválasztásának lehetősége a gombok segítségével.

Ebből arra következtethetünk, hogy a fő feladatok a következők: a szórakoztatás és az ember logikai potenciáljának fejlesztése.

1.2 Ismert, hasonló funkciókat ellátó programok áttekintése

Az interneten számos olyan alkotást találhat, amely megvalósítja ezt a játékot. Jelenleg ennek a játéknak számos analógja van, amelyek eltértek az eredeti szabványoktól. Ilyen programok például a „Tic-tac-toe egy végtelen mezőn” és a „Tic-tac-toe 3D”. Ezenkívül sok játékban a „kereszteket” és a „lábujjakat” más szimbólumokkal helyettesítik, mint például a „kövek”.

A tanfolyami projektem egy PC-s alkalmazás. A játék mind egy felhasználónak szól, akinek az ellenfele a mesterséges intelligencia (vagy egy számítógép), és két felhasználónak. Klasszikus 3x3-as pályán mutatják be.

A legérdekesebb és legszokatlanabb véleményem szerint a „Tic Tac Toe 3D” játék volt. Ezért választottam összehasonlításnak.

A 3D tic-tac-toe sokkal érdekesebb, mint papíron vagy egy normál táblán. Több lehetőség van nyerni és veszíteni, a döntetlenek ritkábban fordulnak elő. Játszhatsz egyedül - a számítógép ellen - vagy egy barátoddal együtt. És a legszokatlanabb itt az, hogy a nyeréshez három saját színű (fekete vagy fehér) golyó kombinációját készítheted nem csak egy szinten, hanem a falak síkja mentén, sőt átlósan az egész mezőn ( 1.1. ábra).

Rizs. 1.1

A sokféle, hasonló témájú játék közül minden munkában kiemelhetjük a terv egyedi megvalósítását. Minden projekt egyéniségében különbözik a többitől.

1.3 A fejlesztés elméleti alapjai

Elemzés

Mindegyik fél számára vannak jól ismert algoritmusok, amelyek garantálják a döntetlent bármely ellenfél játékában, és ha az ellenfél hibázik, lehetővé teszik a győzelmet. Tehát a játék állapota "senki halála"<#"877528.files/image002.gif">

1.2. Játékhelyzetek fája

A játékhelyzetek egy részleges fája látható az 1.2. ábrán a tic-tac-toe játékhoz. A játékhelyzetek fája a tic-tac-toe játékhoz, ahol a „keresztesek” játékosa megy először és a fenti algoritmus szerint cselekszik, a „lábujjak” játékosa pedig azt tehet, amit akar (és az egyik csúcs egy racionális és egy irracionális cselekvésre, azaz bármely másikra adott), 50 csomópontból áll.

1.4 Fejlesztési eszközök kiválasztása

Céljaink eléréséhez integrált alkalmazásfejlesztő környezetre van szükségünk. Ezért a projektfejlesztés a Microsoft Visual Studio 2008 programozási környezetben valósult meg.

A Microsoft Visual Studio a Microsoft termékcsaládja , beleértve az integrált fejlesztői környezetet szoftver és számos egyéb eszköz. Ezek a termékek lehetővé teszik a konzol alapú fejlesztést alkalmazások és GUI alkalmazások , beleértve a Windows Forms technológia támogatását , valamint weboldalak , webszolgáltatások mint az anyanyelvben , és irányított kódok a Windows által támogatott összes platformhoz ,Windows Mobile ,Windows CE , .NET Framework , Xbox , Windows Phone .NET Compact Framework és Silverlight .

2. TERVEZÉSI RÉSZ A FEJLESZTÉSBEN

2.1 Felhasználói felület fejlesztés

A játékalkalmazás létrehozásakor figyelembe kell venni a termék sikerének egyik fő összetevőjét - a felületet. A program felhasználói felületének mindenekelőtt érthetőnek és vonzónak kell lennie a felhasználó számára. Meg kell próbálnia eltávolítani minden olyan pillanatot, amely elvonja a felhasználó figyelmét vagy kellemetlenséget okoz neki. A teljes programfelület két részre osztható.

) A program főmenüje

Rizs. 2.1 - A program főmenüje

A főmenü úgy lett kialakítva, hogy a felhasználó bekapcsolódhasson a játék hangulatába, így a felület színes, játékos színekben pompázik. A menün keresztül léphet a játékmezőre, megtekintheti a játékszabályokat, vagy kiléphet a játékból.

) Játéktér

2.2. ábra - Játéktér

A játéktér tartalmazza a közvetlen játékterületet, ahol a játékos és a számítógép elhelyezi az ikonjait. A játék elindítása előtt a felhasználónak ki kell választania a játék típusát, például "X vs 0", "1 level with computer" vagy "2 level with computer", ellenkező esetben a program üzenetet ad a teendőkről. Egy gomb, amely segít a játékosnak visszatérni a főmenübe. A végén további ablakok jelennek meg, amelyek tájékoztatják a résztvevőt a mérkőzés eredményéről.

Rizs. 2.3 - további játék kimenetele ablakok

2.2 Adatstruktúrák fejlesztése (külső és RAM-ban)

A RAM-ot egy 9 elemből álló egydimenziós tömbhöz használják, amely a játékmező állapotait tárolja, ahol a tömb minden cellája a játékmező egy cellájának felel meg. A memóriát statikus változókra is fordítják: szintszám, fordulatsorrend.

Működéséhez 803 KB szabad memória szükséges.

.3 Algoritmusok fejlesztése és elemzése

A játék gondolkodási algoritmusának megvalósításához be kell állítani egy statikus tömböt gcnew array (9); amelyben a játéktér állapotai lesznek tárolva, ahol a tömb minden cellája egy cellának felel meg. "0" - egy üres cellának felel meg, ha egy játékos beköltözött a cellába, azaz "X", akkor az "1" érték kerül rögzítésre, és ha a számítógép mozdult, azaz "O", akkor az érték „2”. Kezdetben minden tömbelem egyenlő "0"-val. Be kell állítani az lvl statikus változót, amely szintadatokat tárol. Ebben a játékban összesen 3 szint van: az lvl „1” értéket vesz fel, ha a felhasználó az „X vs O” játéktípust választotta, a „2” értéket, ha „1. szint számítógéppel”, és a „3” értéket. ” ha „2. szint számítógéppel” ” A játékos változó a körsorrendet tárolja (az „igaz” a játékos köre, a „hamis” a számítógép köre). Mivel az első lépés joga a felhasználót illeti meg, a játék elején = igaz. A jelző statikus változó információt tárol arról, hogy vannak-e üres cellák a játékmezőn vagy sem: ha flag = igaz - azaz hamis - nincsenek üres cellák. Az ellenőrző algoritmusnak tartalmaznia kell az x tömb paramétereinek iterációját, és elő kell írnia a saját megoldását, amely optimális lesz a további lejátszáshoz. Ez a program 2 szinten kínál számítógépes játékot. 1. szinten a számítógép feladata nem az ellenfél legyőzése. Ezért ezt a funkciót annak a cellának a véletlenszerű értékét adja vissza, ahová a számítógép kerül. Ennek az algoritmusnak a kódja az [1. mellékletben] található. A 2.4. ábra a kód megvalósításának blokkdiagramját mutatja.

A játék elején a legnyertesebb lépés az, ha a pálya közepére mozdulunk. A dif_level() függvényben egy feltételt ellenőrzünk az elején: ha a játékos nem ment a központi mezőre, akkor a számítógép odamegy. Ellenkező esetben, ha a játékos középre ment, akkor a check(2) függvény meghívása ellenőrzi a számítógép kombinációját, és ha van lehetőség nyerni, akkor visszaadja a cellaszámot. Ha a számítógép nem tud nyerni a következő lépésnél, akkor a check(1) függvényt hívják: a játékos kombinációjának ellenőrzése. Annak a cellának a száma, amelyben a játékos nyert volna, ha visszakapja a fogadást. Ha nincs ilyen kombináció, akkor a low_level() függvény kerül meghívásra.

2.4. - Blokk diagramm

2.5. - Blokk diagramm

3. A PROGRAM MEGVALÓSÍTÁSA C++ NYELVEN

.1 Program architektúra

Ez a program 3 formát valósít meg: a főmenüt (2.1. ábra), a játékteret (2.2. ábra) és a súgómezőt (játékszabályok); 12 panel, ebből 9 fő. Továbbá a játék végén megjelenik egy pictureBox az eredménnyel, összesen 5 van (2.3. ábra).

A panel kattintáskezelőit vehetjük alapul, amelyekből pontosan 9 van a játéktéren. Minden kezelő több függvényt hív meg. Kezdetben van egy feltétel, ha a felhasználó az „X versus 0” játéktípust választja, a cellák egyszerűen megtelnek 1 vagy 2 értékkel (kereszt vagy nulla). Következnek a függvények: folyamatjelző (CrossZero()), ami a keresztet nullára változtatja és fordítva, a foglalt cellák blokkolása checkingArray(), a győztes megtalálása(). A győztes() függvény figyelembe veszi az összes lehetséges nyerési lehetőséget, így ha az egyik játékos 3 bábuját (egy keresztet vagy nullát) függőlegesen, vízszintesen vagy átlósan sorba állít, akkor nyer. Ellenkező esetben, ha a mező tele van, de egyik játékos sem állt be, akkor a (_friend()) döntetlen ellenőrző függvény hívódik meg, amely ellenőrzi, hogy vannak-e szabad cellák a pályán vagy sem. Ha fr = igaz, akkor a mezőben nincsenek szabad cellák. Ha az érték megváltozott, az azt jelenti, hogy van egy szabad cella a mezőben.

A második feltétel akkor működik, ha a második vagy a harmadik játéktípus van kiválasztva. Ekkor azt a függvényt, amelyben a számítógép mozgása megtörtént, nevezzük: move(int n). Továbbítja annak a cellának a számát, amelyre a játékos rákattintott. Következnek a függvények: folyamatjelzés (CrossZero()), elfoglalt cellák blokkolása checkingArray(). Ezután meghívódik a nyertes() függvény, amely ellenőrzi, hogy a játékos nyert-e ezzel a lépéssel vagy sem. Ha nem, akkor ellenőrizni kell a szabad sejtek jelenlétét. Ha vannak szabad cellák, akkor a számítógép mozog. Ezután attól függően, hogy az „1” vagy a „2” játékos melyik szintjét választotta, a következő függvényeket hívjuk meg: low_level(), dif_level(). A low_level() függvény véletlenszerűen választja ki, hogy hol helyezze el a nullát, a dif_level() függvény pedig egy speciális algoritmust mutat be, amellyel a számítógép nyerhet. Következnek a függvények: folyamatjelzés (CrossZero()), elfoglalt cellák blokkolása checkingArray(). Ezután meghívódik a winner() függvény, amely ellenőrzi, hogy a számítógép nyert-e ezzel a lépéssel vagy sem. Ha nem, akkor ellenőrizni kell a szabad sejtek jelenlétét. Ha vannak szabad cellák, akkor a játékos mozog.

.2 Szabványos vizuális és nem vizuális komponensek kiválasztása

A munka végrehajtásához a következő összetevőket választottuk ki:

1) Form1, with adott paramétereket Text=Tic-Tac-Toe, ControlBox=hamis

2) f2, a megadott paraméterekkel: BackColor, Text=Game

) comboBox1 a megadott Items paraméterekkel:

X vs 0

1. szint számítógéppel

2. szint számítógéppel

4) panel, meghatározott BackColor paraméterekkel, valamint a Visible és Enabled paraméterek különböző értékeivel. Egyes panelekhez olyan eseményeket írtak, mint például a Click.

5) gomb, a megadott paraméterekkel: Font, Fore Color, BackColor, Text, minden olyan gombhoz, mint például a kattintás, megírták.

6) címke, a megadott paraméterekkel: BackColor, Font, Fore Color, Text.

) pictureBox, megadott paraméterekkel Image, SizeMode= StretchImage.

) textBox, a megadott paraméterekkel BackColor, Font, Fore Color, Text=” ”.

4. VIZSGÁLATI EREDMÉNYEK

Teszteljük a programot úgy, hogy végigmenünk 3 féle játékon.

Próbáljuk ki a főmenü gombjainak műveleteit. A gombok megfelelően működnek. Próbáljuk elindítani a játékot játéktípus kiválasztása nélkül. A program hibaüzenetet jelenít meg, és kéri a játék típusának kiválasztását (4.1. ábra)

4.1.

Válasszunk 1 típusú játékot - „X versus 0”, azaz. felhasználó kontra felhasználó. A játék ezen szakaszában a felhasználó önmagával is játszhat. (4.2. ábra)

4.2.

Az „1. szint a számítógéppel” játék során a számítógép nem azt a célt tűzi ki maga elé, hogy megnyerje a résztvevőt. Csak nullákat ír be szabad helyek mezőket. Ebben a szakaszban a felhasználó könnyedén legyőzheti a számítógépet. Bár ezen a szinten más lehetőségek is lehetségesek az események fejlesztésére.

4.3.

Játéktípus: „2. szint számítógéppel”. Ebben a szakaszban a játék elemzi az összes lépést, és megpróbálja kiválasztani a legoptimálisabb lépést. Itt is mindhárom forgatókönyv lehetséges, mert A számítógép megteszi az első lépést bármely szabad cellába. Leggyakrabban döntetlenre dől el a játék.

4.4.

A program minden tesztváltozaton sikeresen fut, hiba nélkül.

KÖVETKEZTETÉS

Bátran kijelenthetjük, hogy a munka elején kitűzött feladatot teljesítettük. A fejlesztés során egy projektet terveztek és fejlesztettek ki a híres „Tic Tac Toe” játék remixére. A játék megfelel a meghatározott követelményeknek és teljesíti a funkcióit. A munkában megvalósítva Különféle típusok játékok és nehézségi szintek.

A munka során új programozási módszereket sajátítottak el integrált fejlesztői környezetben. A C++ nyelvvel való munkavégzés régi ismeretei megszilárdultak. A tanfolyami munkára való felkészülés során különféle módszereket és algoritmusokat elemeztek a játék megvalósítására.

A program látszólagos egyszerűsége ellenére számos nehézséggel jár, amelyeket a Visual C++ összes alapvető technikájával hajtanak végre.

Ennek a programnak a jellemzői a következők:

Egyértelműen felépített algoritmus;

Intuitív interfész;

Könnyen kezelhető;

Elég világos felhasználói kézikönyv;

Nincsenek felesleges kiegészítők.

BIBLIOGRÁFIA

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

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

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

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

1. MELLÉKLET

private: int low_level())(// eljárás egy könnyű ellenfél számára;::Random^ rand = gcnew System::Random();(= rand->Next(0,8);

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

2. MELLÉKLET

privát: bool check(int n)(k = -1;// ellenőrzi az összes kombinációt, és a megfelelő lépést adja vissza(x == n) (((x == n)&&(x == 0)) k =2; ((x == n)&&(x == 0)) k =1;((x == n)&&(x == 0)) k =6;((x == n)&&(x == 0)) k =3;((x == n)&&(x == 0)) k =8;((x == n)&&(x == 0)) k =4;

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

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

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

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

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

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

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

)(k!=-1) return true;else return false;

3. FÜGGELÉK

privát: int dif_level())(//nehéz ellenség

//vissza check(2);(x == 0) return (4);(check(2)) return k; else (check(1)) return k; else low_level();

ALKALMAZÁS 4

private: void CrossZero())(// a keresztet nullára változtatja (haladásjelző)(lejátszó) (->Visible = true;->Visible = false;

) else (->Látható = igaz;->Látható = hamis;

): void checkingArray())(// funkció, amely ellenőrzi, hogy van-e valami a cellában, ha van, akkor erre a cellára többé nem kattinthat.(x == 1) (panel1->BackgroundImage = panel11->BackgroundImage ;panel1- >Enabled = 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- >Engedélyezve = false;)(x == 2) (panel9->BackgroundImage = panel10->BackgroundImage;panel9->Enabled = false;)

): bool winner())(// a győztes ellenőrzése és az összes többi cella blokkolása.

//bool flag = 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;-> Engedélyezve = false;->Engedélyezve = hamis;->Engedélyezve = hamis;->Engedélyezve = hamis;->Engedélyezve = hamis;igaz;

)(((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;-> Engedélyezve = false;->Engedélyezve = hamis;->Engedélyezve = hamis;->Engedélyezve = hamis;igaz;

): void _barát())(fr = igaz;(int i = 0; i< 9; i++) if (x[i] == 0) {fr = false; break;}(fr) { pictureN->Látható = igaz ;)

): void move(int n)(// számítógép áthelyezési függvény= false;[n] = 1;= !játékos;();();(győztes()) () ((int i = 0; i< 9; i++) if (x[i] == 0) flag = true;(flag){(lvl == 2) = 2; = 2;= !player;();();();

): System::Vid button1_Click(Rendszer::Object^ feladó, System::EventArgs^ e) (// új játék>Visible = false;>Visible = false;>Visible = false; >Visible = false; >Visible = false; = comboBox1->Szöveg;(typeGame == "")(::Show("Először válassza ki a játék típusát!");

) else ((typeGame == "X versus 0") lvl = 1;(typeGame == "1. szint számítógéppel") lvl = 2;(typeGame == "2. szint számítógéppel") lvl = 3;( ); = igaz;(int i = 0; i< 9; i++) x[i] = 0;->BackgroundImage = panel12->BackgroundImage;->BackgroundImage = panel12->BackgroundImage;->BackgroundImage = panel12->BackgroundImage;->BackgroundImage = panel12->BackgroundImage;->BackgroundImage = panel12->BackgroundImage =panel12->Háttérkép; BackgroundImage;->BackgroundImage = panel12->BackgroundImage;->BackgroundImage = panel12->BackgroundImage;->BackgroundImage = panel12->BackgroundImage;->Enabled = true;->Enabled = true;->Enabled = true;->Enabled = true;->Enabled = igaz;->Engedélyezve = igaz;->Engedélyezve = igaz;->Engedélyezve = igaz;->Engedélyezve = igaz;->Engedélyezve = igaz;

): System::Void panel1_MouseClick(Rendszer::Object^ feladó, Rendszer::Windows::Forms::MouseEventArgs^ e) (n = 0;(lvl == 1)((lejátszó)( = 1;

)= !lejátszó;();();();

): System::Void panel2_MouseClick(Rendszer::Object^ feladó, Rendszer::Windows::Forms::MouseEventArgs^ e) (n = 1;(lvl == 1)((lejátszó)( = 1;

)= !lejátszó;();();();