casa › Installazione e configurazione › Creazione di un gioco di tris. Fondamenti teorici dello sviluppo

Creazione di un gioco di tris. Fondamenti teorici dello sviluppo

Saluti, cari amici! In questa lezione mostrerò come creare un gioco per browser: tris, in javascript! Sapete tutti cos'è questo gioco e come si gioca, ma lasciate che ve lo ricordi ancora:

Il tris è un gioco logico tra due giocatori su un campo quadrato di 3 x 3 celle (possibilmente più grande). Uno gioca con le “croci” e il secondo con le “punte”.

PS come in tutte le lezioni simili di Javascript, alla fine dell'articolo puoi scaricare il file sorgente e anche vedere il risultato del lavoro in un esempio demo!

Descrizione del gioco in creazione

Diamo un'occhiata alle caratteristiche del gioco:

il gioco inizia immediatamente dopo il caricamento della pagina;
il diritto ad andare per primo viene scelto casualmente (o si inizia a camminare o si inizia al computer);
il segno che scommetterai viene scelto casualmente (una croce o uno zero);
se il giocatore vince, i simboli vincenti (una striscia di croci o zeri) vengono evidenziati in verde;
se il giocatore perde contro il computer, la barra viene evidenziata in rosso;
Sopra il campo è presente una riga informativa dove viene visualizzato il risultato (vittoria o sconfitta).

Logiche

Non ho inventato algoritmi complessi (universali) per un campo di gioco quadrato 3 x 3, sono andato nella direzione opposta: forza bruta! (ne parleremo più avanti un po'). Ho identificato tre fasi sequenziali principali su cui poggia tutta la logica:

Fase 1: verificare se il giocatore ha vinto?

A questo punto controlliamo se ci sono 3 celle (sulla stessa riga) riempite con gli stessi simboli del giocatore (croci o zeri). Quelli. non importa quale sia la mossa (anche la prima), controlliamo sempre prima se il giocatore ha vinto. Ecco come appare la vittoria:

Fase 2: controllo: il computer può vincere con la mossa successiva?

In questa fase, stiamo cercando una linea in cui ci siano 2 celle riempite dal computer e una cella vuota, ovvero stiamo cercando di vincere a causa della disattenzione del giocatore. Ecco come appare la sconfitta (cioè una vittoria del computer):

Fase 3: non ti lasciamo vincere!

Qui stiamo cercando la stessa riga della seconda fase, solo 2 celle devono essere riempite con i segni di gioco del giocatore, cioè in questa fase non permettiamo al computer di perdere posizionando un segno in una cella vuota. Ciascuna delle fasi rappresenta una funzione indipendente: puoi vederla nel codice js seguente.

Implementazione

Il layout del campo di gioco è molto semplice: il blocco principale contiene una riga di informazioni (classe - risultato) e 9 blocchi, che sono celle (classe - blocco) layout HTML delle celle:

Il tuo turno!

La cella della classe ausiliaria è necessaria per identificare con precisione la cella desiderata sul campo di gioco. Stili CSS per il campo di gioco:

Krestiki_noliki( larghezza: 306px; margine: 0 automatico; ) .krestiki_noliki .block( larghezza: 100px; altezza: 100px; bordo: 1px solido #ccc; cursore: puntatore; float: sinistra; allineamento testo: centro; dimensione carattere: 100px; altezza della linea: 94px; )

Ora diamo un'occhiata all'intero codice JS, dopodiché parlerò dei punti principali:

$(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"]; //Determina la funzione di vittoria del giocatore 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; } }); });

Per prima cosa dichiariamo le variabili: znak_user - in questa variabile memorizziamo il segno con cui l'utente giocherà (per impostazione predefinita, lì viene memorizzato uno zero - questa è la casella inglese "O"). znak_comp - in questa variabile memorizziamo il segno con cui il computer giocherà (per impostazione predefinita, lì è memorizzata una croce - questa è la casella inglese "X").

La logica è questa: se il numero casuale è maggiore di 3, il computer gioca con gli zeri e lui (il computer) fa la prima mossa.

Puoi modificare questa logica come preferisci, ad esempio puoi creare diversi numeri casuali per avere più opzioni su chi sarà il primo e quali segni. exit_flag - questo flag (variabile) è responsabile dell'uscita dalla funzione, ovvero, ad esempio, quando il computer ha già eseguito la sua mossa ed è necessario uscire dalla funzione e passare la mossa al giocatore. win_user_array: questo array memorizza tutte le opzioni vincenti per riempire le celle. Per essere più chiari, diamo un'occhiata a questa immagine:

Ogni elemento dell'array è una stringa di tre numeri, che è una combinazione vincente, ovvero, ad esempio, se riempi le celle sotto i numeri 1, 2 e 3, si verificherà la vittoria (o la sconfitta). Come puoi vedere, ci sono 8 opzioni vincenti in totale; il nostro compito è esaminare tutte queste opzioni. Poi ci sono 3 funzioni:

controlla_3_utente();
controlla_2_comp();
controlla_2_utente();

Lo scopo di queste funzioni è descritto (in tre passaggi) nella sezione Logica (sopra). Queste funzioni vengono richiamate facendo clic su una qualsiasi delle celle nel campo. Un parametro (znak) viene passato a ciascuna delle funzioni: questo è il segno del giocatore o del computer (una croce o uno zero), ad esempio, alla funzione che determina la vittoria del giocatore (check_3_user), passiamo il segno del giocatore in ordine per trovare 3 segni identici sulla stessa linea.

Dopo tre funzioni (se il computer non ha ancora effettuato una mossa), il computer riempie una delle celle libere. In questo caso puoi complicare il gioco, ad esempio, facendo in modo che se la cella centrale è libera (cella numero 5), scommetti prima su di essa; se è occupata, scommetti su uno degli angoli liberi (questi sono celle n. 1, 3, 7 e 9) e così via - in generale, qui dipende dalla tua discrezione.

Questo, in linea di principio, è tutto ciò che serve per creare un gioco del genere.

Ora puoi guardare la partita utilizzando un esempio demo e scaricare il file sorgente (1 file in totale).

06/08/2018 - grazie per l'attenzione all'autore della lettera: Patvakan Baghdasaryan, è stato corretto un bug quando il computer ne aveva diversi possibili opzioni le vittorie e tutte le sue mosse vincenti venivano ridipinte (da 4 a 6 caselle, invece di 3).

Per me questo è tutto, spero che questa lezione ti sia stata utile, ti auguro buona fortuna, ciao!

Come scrivere un bot che non può essere battuto a tris, o Introduzione alla regola del minimax

È possibile che dopo centinaia di partite a tris vi siate chiesti: qual è l'algoritmo ottimale? Ma se sei qui, probabilmente hai anche provato a scrivere un'implementazione di questo gioco. Andremo oltre e scriveremo un bot che sarà impossibile battere a tris. Anticipando la tua domanda “perché?”, risponderemo: grazie all’algoritmo.

Come un giocatore di scacchi professionista, questo algoritmo calcola le azioni dell'avversario diverse mosse in anticipo, fino al raggiungimento della fine della partita, che si tratti di una vittoria, di una sconfitta o di un pareggio. Una volta in questo stato finale, l'IA si assegnerà un numero di punti positivo (nel nostro caso +10) per la vittoria, negativo (-10) per la sconfitta e neutro (0) per il pareggio.

Allo stesso tempo, l’algoritmo esegue calcoli simili per le mosse del giocatore. Sceglierà la mossa con il punteggio più alto se si muove l'IA, e la mossa con il punteggio più basso se si muove il giocatore. Usando questa strategia, minimax evita la sconfitta.

Prova a giocare a questo gioco.

L’algoritmo minimax è più facilmente descritto come una funzione ricorsiva che:

restituisce un valore se viene trovato lo stato finale (+10, 0, -10),
attraversa tutte le celle vuote del campo,
chiama la funzione minimax per ciascuno di essi (ricorsione),
valuta i valori ottenuti
e restituisce il migliore.

Se non hai familiarità con la ricorsione, dovresti guardare questa lezione del corso Harvard CS50:

Per capire come funziona minimax, scriviamo la sua implementazione e modelliamo il suo comportamento. Ci occuperemo di questo nelle prossime due sezioni.

Implementazione Minimax

Considereremo una situazione in cui il gioco sta per finire (vedi immagine sotto). Poiché minimax attraversa tutti i possibili stati del gioco (e ce ne sono centinaia di migliaia), ha senso considerare il gioco finale: in questo modo dovremo tenere traccia di un numero minore di chiamate di funzioni ricorsive (9 in totale).

Lascia che l'IA giochi con le croci, la persona con gli zeri.

Per facilitare il lavoro con il campo, dichiariamolo come un array di 9 elementi con valori uguali al contenuto delle celle. Riempiamolo con croci e dita dei piedi, come nell'immagine sopra, e chiamiamolo origBoard.

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

Successivamente, dichiareremo le variabili aiPlayer e huPlayer e assegneremo loro rispettivamente i valori "X" e "O".

Inoltre, avremo bisogno di una funzione che cerchi le combinazioni vincenti e restituisca un valore vero se la ricerca ha esito positivo, e di una funzione che memorizzi gli indici delle celle disponibili.

/* stato iniziale tavole O | | X --------- X | | X --------- | O | O */ var origBoard = [“O”,1 ”,X”,”X”,4 ”,X”, 6 ”,O”,”O”]; // persona var huPlayer = “O”; // AI var aiPlayer = “X”; // restituisce un elenco di indici di celle vuote sulla funzione board emptyIndices(board)( return board.filter(s => s != "O" && s != "X"); ) // combinazioni vincenti tenendo conto indici funzione vincente(tabellone, giocatore)( if((tabellone == giocatore && tabellone == giocatore && tabellone == giocatore) || (tabellone == giocatore && tabellone == giocatore && tabellone == giocatore) || (tabellone = = giocatore && tabellone == giocatore && tabellone == giocatore) || (tabellone == giocatore && tabellone == giocatore && tabellone == giocatore) || (tabellone == giocatore && tabellone == giocatore && tabellone == giocatore) | | (tabellone == giocatore && tabellone == giocatore && tabellone == giocatore) || (tabellone == giocatore && tabellone == giocatore && tabellone == giocatore) || (tabellone == giocatore && tabellone == giocatore && tabellone = = giocatore)) (restituisce vero;) else (restituisce falso;))

Quindi definiamo una funzione minimax con due argomenti: newBoard e player. Successivamente troveremo gli indici delle celle libere sul campo e li passeremo alla variabileavailSpots.

// funzione principale minimax function minimax(newBoard, player)( // celle disponibili var disponibiliSpots = emptyIndices(newBoard);

Inoltre, dobbiamo tenere traccia degli stati finali e restituire i valori appropriati. Se lo "zero" vince, devi restituire -10, se la "croce" - +10. Se la dimensione dell'arrayavailSpots è zero, non ci sono celle libere, il gioco finirà con un pareggio e sarà necessario restituire zero.

// verifica lo stato del terminale (vittoria/sconfitta/pareggio) //e restituisce un valore di conseguenza if (wining(newBoard, huPlayer))( return (score:-10); ) else if (wining(newBoard, aiPlayer)) ( return (punteggio:10); ) else if (availSpots.length === 0)( return (punteggio:0); )

Successivamente, devi raccogliere punti da ciascuna delle celle vuote. Per fare ciò, creeremo una serie di mosse ed esamineremo tutte le celle vuote in un ciclo, posizionando gli indici e i punti di ciascuna mossa nell'oggetto mossa.

Quindi impostiamo l'indice della cella vuota, che è stata memorizzata come numero in origBoard, uguale alla proprietà indice dell'oggetto di spostamento. Quindi andremo come giocatore attuale in una cella vuota del nuovo campo newBoard e chiameremo la funzione minimax dell'altro giocatore e il campo risultante newBoard . Successivamente, è necessario inserire la proprietà score dell'oggetto restituito dalla funzione minimax nella proprietà score dell'oggetto di spostamento.

Se minimax non trova uno stato terminale, continua a spostarsi ricorsivamente più in profondità nel gioco finché non raggiunge uno stato terminale. Successivamente trasferisce i punti di questo “livello” di ricorsione ad un livello superiore.

Infine, la funzione reimposta le modifiche su newBoard e inserisce l'oggetto move nell'array moves.

// array per memorizzare tutti gli oggetti var move = ; // scorre le celle disponibili per (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 deve quindi selezionare la mossa migliore dall'array di mosse. Ha bisogno della mossa con il punteggio più alto se è l'IA a muoversi, e con il più basso se si tratta di una mossa umana. Pertanto, se il valore di player è aiPlayer , l'algoritmo inizializza la variabile bestScore su un numero molto piccolo e scorre l'array delle mosse: se il punteggio di una mossa vale più punteggio di bestScore , l'algoritmo ricorda quella mossa . Nel caso di mosse con punti uguali, l'algoritmo ricorda la prima.

Nel caso in cui player sia uguale a huPlayer , tutto è simile: solo che ora bestScore è inizializzato su un numero elevato e minimax cerca la mossa con il minor numero di punti.

Di conseguenza, minimax restituisce l'oggetto memorizzato in bestMove .

// se si tratta di una mossa AI, scorre le mosse e seleziona la mossa con il maggior numero di punti var bestMove; if(giocatore === aiPlayer)( var migliorpunteggio = -10000; for(var i = 0; i< moves.length; i++){ if(moves[i].score >bestScore)( bestScore = goes[i].score; bestMove = i; ) ) )else( // altrimenti scorre le mosse e seleziona la mossa con il minor numero di punti var bestScore = 10000; for(var i = 0; i< moves.length; i++){ if(moves[i].score < bestScore){ bestScore = moves[i].score; bestMove = i; } } } // вернуть выбранный ход (объект) из массива ходов return moves; }

Nella prossima sezione simuleremo il nostro programma per capire come funziona.

Minimax in azione

Utilizzando il diagramma seguente, analizzeremo il modello passo passo dell'algoritmo.

Nota: Nel diagramma, i numeri grandi indicano il numero di serie della chiamata alla funzione e i livelli indicano quante mosse è andata avanti dall'algoritmo.

L'origBoard e aiPlayer vengono alimentati all'algoritmo. Crea un elenco delle tre celle vuote trovate, controlla la finitezza dello stato e scorre tutte le celle vuote. L'algoritmo cambia quindi newBoard , posizionando aiPlayer nel primo quadrato vuoto. Successivamente, si richiama da newBoard e huPlayer e attende la seconda chiamata per restituire un valore.
Mentre la prima chiamata di funzione è ancora in esecuzione, viene eseguita la seconda, creando un elenco di due celle vuote, verificando lo stato finito e scorrendo tutte le celle vuote. La seconda chiamata modifica quindi newBoard posizionando huPlayer nel primo quadrato vuoto. Successivamente, si richiama da newBoard e aiPlayer e attende la terza chiamata per restituire un valore.
Poiché la seconda chiamata ha trovato due celle vuote, minimax modifica newBoard posizionando huPlayer nella seconda cella vuota. Quindi si richiama da newBoard e aiPlayer.
L'algoritmo compila un elenco di celle vuote e registra la vittoria del giocatore dopo aver verificato la finitezza dello stato. Quindi restituisce un oggetto con un campo punteggio pari a (-10).
Nella seconda chiamata di funzione, l'algoritmo riceve i valori restituiti dal livello inferiore dalle chiamate della terza e quarta funzione. Poiché la mossa di huPlayer ha prodotto questi due risultati, l'algoritmo sceglie quello più piccolo. Poiché sono uguali, l'algoritmo sceglie il primo e lo passa alla prima chiamata di funzione.

A questo punto, la prima chiamata di funzione ha ricevuto una stima dello spostamento di aiPlayer nella prima cella vuota. Quindi modifica newBoard posizionando aiPlayer nel secondo quadrato vuoto. Successivamente, si richiama da newBoard e huPlayer.
Nella quinta chiamata di funzione, l'algoritmo compila un elenco di celle vuote e registra la vittoria dell'IA dopo aver verificato la finitezza dello stato. Quindi restituisce un oggetto con un campo punteggio pari a +10.
Successivamente, la prima chiamata modifica newBoard posizionando aiPlayer nella terza cella vuota. Quindi si richiama da newBoard e huPlayer.
La sesta chiamata crea un elenco di due celle vuote, controlla la finitezza dello stato e scorre tutte le celle vuote. Quindi modifica newBoard posizionando huPlayer nel primo quadrato vuoto. Quindi si richiama da newBoard e aiPlayer e attende la settima chiamata per restituire un valore.
La nuova chiamata costruisce un elenco di una cella vuota, controlla lo stato finito e modifica newBoard per posizionare aiPlayer nella cella vuota. Successivamente, richiama se stesso da newBoard e huPlayer e attende che questa chiamata restituisca un valore.
L'ottava sfida è elenco vuoto celle vuote e registra la vittoria di aiPlayer dopo aver controllato lo stato degli arti. Pertanto restituisce un oggetto con un campo count pari a (+10) al livello superiore, la settima chiamata.
La settima chiamata ha ricevuto solo un valore positivo dai livelli inferiori. Poiché questo valore è stato ottenuto durante il turno di aiPlayer, l'algoritmo restituisce il valore più grande ottenuto. Quindi restituisce un valore positivo (+10) al livello superiore, la sesta chiamata.

Poiché la sesta chiamata ha trovato due celle vuote, minimax modifica newBoard posizionando huPlayer nella seconda cella vuota. Quindi si richiama da newBoard e aiPlayer.
Successivamente, l'algoritmo compila un elenco di celle vuote e registra la vittoria di aiPlayer dopo aver verificato la finitezza dello stato. Pertanto, restituisce un oggetto con un campo punteggio pari a (+10) al livello superiore.
A questo punto la sesta sfida dovrà scegliere tra il punteggio (+10) restituito dalla settima sfida e il punteggio (-10) restituito dalla nona sfida. Poiché la mossa di huPlayer ha prodotto questi due risultati, l'algoritmo seleziona quello più piccolo e lo restituisce al livello successivo come oggetto con campi punteggio e indice.

Infine vengono valutati tutti e tre i rami della prima chiamata (-10, +10, -10). Poiché la mossa di aiPlayer ha prodotto questi tre risultati, l'algoritmo seleziona l'oggetto contenente il maggior numero di punti (+10) e il suo indice (4).

Nello scenario sopra, minimax lo decide scelta ottimale ci sarà lo spostamento nella piazza centrale del campo.

FINE!

A questo punto dovresti aver capito come funziona l'algoritmo minimax. Prova a scrivere tu stesso un'implementazione o guarda un esempio su GitHub o CodePen e ottimizzalo.

Se sei interessato all'argomento dell'intelligenza artificiale nei giochi, ti consigliamo di leggere i nostri materiali su questo argomento.

PASSO 1. CONFIGURAZIONE DEI PARAMETRI DEL MODULO1. Per personalizzare un modulo, impostarne le dimensioni
510 punti in orizzontale e 480 punti in orizzontale
verticale. Massimo e minimo
indicare la dimensione pari agli stessi valori.
2. Assegna un nome alla forma "Tic Tac Toe".
3. Per lo sfondo del modulo, utilizzare un file dalla cartella
Immagini sotto il nome background.png e posizionale
al centro del modulo.
4. Per un'icona nella riga del titolo
usa usa il file dalla cartella
Immagini sotto il nome menu4.ico.
5. È necessario impostare il colore di sfondo del modulo
Crema Di Menta.

PASSO 2. AGGIUNTA DI UN PULSANTE ED ETICHETTA AL FORM

1. Per gli elementi posizionati, modificare
dimensione del carattere su 12 e sfondo impostato
trasparente.

1. Crea una barra dei menu con gli elementi in
come mostrato nell'immagine.

PASSO 3. AGGIUNTA DI UNA BARRA DEI MENU AL FORM

1. Alla voce di menu File creare un comando
Uscita.
2. Per
squadre
Uscita
prescriviamo
il codice del programma è lo stesso di
precedente applicazione.

PASSO 3. AGGIUNTA DI UNA BARRA DEI MENU AL FORM

1. Alla voce di menu Gioco, crea una squadra
Un nuovo gioco.
2. Per il comando Nuovo gioco scriveremo
codice di programma in futuro tramite
pochi passi.

PASSO 3. AGGIUNTA DI UNA BARRA DEI MENU AL FORM

1. Nella voce del menu Aiuto, creare un comando
Informazioni sul programma.
2. Per il comando Informazioni sul programma, crearne uno nuovo
form e scrivere il codice del programma
simile al precedente
applicazione.

1. Trascinando un oggetto PictureBox sul modulo
cambiarne le dimensioni in 100x100.
2. Imposta uno sfondo trasparente.
3. Posizionare PictureBox come mostrato in
immagine sopra la prima cella del campo di gioco.

PASSO 4. AGGIUNTA DI OGGETTI PICTUREBOX AL FORM

1
2
3
4
5
6
7
8
9
1. Sopra le celle rimanenti posizioniamo
Oggetti PictureBox, copie del primo
oggetto, secondo la numerazione indicata su
Immagini.

1. Prima di scrivere il codice
necessario nella cartella
\Studio visivo
2010\Progetti\Tic Tac Toe\X's
zeros\bin\Debug\ deve essere rilanciato
file x.png, 0.png, none.png dalla cartella Immagini.
2. Fare doppio clic con il tasto sinistro del mouse sul primo
PictureBox.

PASSO 5. AGGIUNTA DEL CODICE PER GLI OGGETTI PICTUREBOX

1. Crea un array bidimensionale accessibile a tutti gli elementi in
creato sotto forma di elementi 3x3 costituiti da numeri interi. Subito
lo riempiamo con zeri quando lo dichiariamo. Per le celle vuote noi
Useremo 0, per "croci" - 1 e per "zero" - -1.

PASSO 5. AGGIUNTA DEL CODICE PER GLI OGGETTI PICTUREBOX

Nella procedura quando si fa clic sul primo
PictureBox, aggiungi un operatore
scelta
Quale
Volere
controllare lo stato
celle dell'array. Se il valore
le celle dell'array saranno uguali a 0, che
ciò significa che non esiste né “zero” né
“croce”, quindi in questa cella
l'array è scritto 1 e in
PictureBox1
visualizzato
immagine di una “croce”, e se
il valore della cella dell'array sarà
è uguale a 1 quindi contiene
"croce" e 0 è scritto in esso, e
Viene visualizzata una cella vuota.

PASSO 5. AGGIUNTA DEL CODICE PER GLI OGGETTI PICTUREBOX

1
2
3
4
5
6
7
8
9

Per le restanti celle del campo, aggiungi il codice
uguale al primo, cambia solo
Numero oggetto PictureBox e indirizzo cella
vettore.
ESEMPIO per la seconda cella:

Nella procedura quando si fa clic su un pulsante
aggiungere
operatore
ciclo
chi controlla
tutte le celle a partire dalla prima alla
presenza di celle vuote. E se
la cella è vuota,
poi dentro di lei
Si scrive “zero”, cioè in
la cella dell'array viene scritta -1.
Per comodità nel lavoro futuro
variabili
IO,
J
Quale
utilizzato per ripetere i cicli
Annunceremo per l'intero modulo.

PASSO 6. AGGIUNTA DEL CODICE PER IL PULSANTE CAMMINA

Per visualizzare gli zeri
gioco
campo
necessario
aggiungi il codice del programma al corpo
ciclo di controllo del vuoto delle celle.
Utilizzando un'istruzione nidificata
ramificazione
Volere
avere luogo
analisi dell'indirizzo della cella dell'array per
uscita zero nel corretto
PictureBox.
Aggiungiamo anche un'istruzione break
per una conclusione anticipata
loop quando viene trovato vuoto
cellule.

PASSO 6. AGGIUNTA DEL CODICE PER IL PULSANTE CAMMINA

Per indicare lo stato del gioco
viene utilizzato l'elemento di interfaccia
Etichetta1. Poiché il giocatore si muove sempre
Primo
Quello
A
download
applicazioni
necessario
V
elemento
Etichetta1
necessario
riflettere
frasi “Il tuo
mossa."
Per
Questo
creiamo
variabile
risposta
Quale
Assegniamo questa frase. UN
quando si carica il modulo una variabile
deve essere assegnato all'elemento
Etichetta1, per creare il necessario
procedure
necessario
fare prima doppio clic
secondo la forma

PASSO 7. AGGIUNTA DEL CODICE DI PROGRAMMA PER LA NUOVA VOCE DEL MENU DI GIOCO

Quando premuto sul comando new
il gioco verrà ripristinato
tutte le celle dell'array, sostituendo all
"croci" e "punte" su
celle vuote. Anche la conclusione
Segni "La tua mossa".

PASSO 8. PUBBLICARE IL RISULTATO DEL GIOCO

Per controllare i risultati delle mosse
necessario
analizzare
contenuto di righe, colonne e
diagonali. Se tutti e tre gli elementi
sono pari a 1, allora questa è una vittoria per il giocatore, e
se tre -1 allora è una sconfitta
giocatore.
È richiesto il controllo della vittoria
condotta
Prima
progresso
computer,
UN
controllo
sconfitta dopo.
L'ultimo comando della procedura
i risultati verranno visualizzati sullo schermo
progresso.

PASSO 8. PUBBLICARE IL RISULTATO DEL GIOCO

Codice del programma per verificare la vittoria dell'utente:
if (znacheniyeYacheyki == 1 && znacheniyeYacheyki == 1 && znacheniyeYacheyki == 1) otvet = "Hai vinto";
if (znacheniyeYacheyki == 1 && znacheniyeYacheyki == 1 && znacheniyeYacheyki == 1) otvet = "Hai vinto";
if (znacheniyeYacheyki == 1 && znacheniyeYacheyki == 1 && znacheniyeYacheyki == 1) otvet = "Hai vinto";
if (znacheniyeYacheyki == 1 && znacheniyeYacheyki == 1 && znacheniyeYacheyki == 1) otvet = "Hai vinto";
if (znacheniyeYacheyki == 1 && znacheniyeYacheyki == 1 && znacheniyeYacheyki == 1) otvet = "Hai vinto";
if (znacheniyeYacheyki == 1 && znacheniyeYacheyki == 1 && znacheniyeYacheyki == 1) otvet = "Hai vinto";
if (znacheniyeYacheyki == 1 && znacheniyeYacheyki == 1 && znacheniyeYacheyki == 1) otvet = "Hai vinto";
if (znacheniyeYacheyki == 1 && znacheniyeYacheyki == 1 && znacheniyeYacheyki == 1) otvet = "Hai vinto";
Codice del programma per verificare la vittoria dell'utente:
if (znacheniyeYacheyki == -1 & znacheniyeYacheyki == -1 & znacheniyeYacheyki == -1) otvet = "Hai perso";
if (znacheniyeYacheyki == -1 & znacheniyeYacheyki == -1 & znacheniyeYacheyki == -1) otvet = "Hai perso";
if (znacheniyeYacheyki == -1 & znacheniyeYacheyki == -1 & znacheniyeYacheyki == -1) otvet = "Hai perso";
if (znacheniyeYacheyki == -1 & znacheniyeYacheyki == -1 & znacheniyeYacheyki == -1) otvet = "Hai perso";
if (znacheniyeYacheyki == -1 & znacheniyeYacheyki == -1 & znacheniyeYacheyki == -1) otvet = "Hai perso";
if (znacheniyeYacheyki == -1 & znacheniyeYacheyki == -1 & znacheniyeYacheyki == -1) otvet = "Hai perso";
etichetta1.Testo = risposta;

PASSO 9 MIGLIORARE LA GIOCABILITA'

Per migliorare la giocabilità
invece dell'uscita seriale
ai primi vuoti
celle di "zero", implementiamo
uscita tramite generatore casuale
numeri.
Per fare ciò è necessario aggiungere
una variabile logica
uslovie e cambia il tipo di ciclo da For
su While, poiché non lo sappiamo
numero esatto di ripetizioni
Generatore numeri casuali Ciao
non cadrà in una cella vuota.

MINISTERO DELL'ISTRUZIONE E DELLA SCIENZA DELLA RUSSIA

istituto di istruzione di bilancio dello stato federale di istruzione professionale superiore

"Università statale di Vologda"

Dipartimento di Ingegneria dell'Automazione e dell'Informazione

Nota esplicativa al progetto del corso nella disciplina

Nozioni di base sulla programmazione e sugli algoritmi

"Tic Tac Toe"

Completato studente del gruppo EM-21

Butorova L.Yu.

Accettato Rzheutskaya S. Yu.

INTRODUZIONE

1. ANALISI DEL PROBLEMA E DETERMINAZIONE DEI REQUISITI PER IL PROGRAMMA DA SVILUPPARE

1 Scopo del programma, suoi utenti, principali funzioni e obiettivi perseguiti durante lo sviluppo

2 Rassegna di programmi noti che svolgono funzioni simili

3 Basi teoriche dello sviluppo

4 Selezione degli strumenti di sviluppo

PARTE PROGETTUALE DELLO SVILUPPO

1 Sviluppo dell'interfaccia utente

2.2 Sviluppo delle strutture dati (in esterna e RAM)

2.3 Sviluppo e analisi di algoritmi

IMPLEMENTAZIONE DEL PROGRAMMA IN LINGUAGGIO C++

1 Architettura del programma

2 Selezione dei componenti visivi e non visivi standard

RISULTATI DEL TEST

CONCLUSIONE

Bibliografia

Applicazioni

INTRODUZIONE

Il tris è un gioco logico tra due avversari su un campo quadrato di 3 x 3 celle o più grande (fino a un “campo infinito”). Uno dei giocatori gioca con le "croci", il secondo con le "punte dei piedi". Questo gioco è diventato popolare molto prima dell'avvento dei computer, solo prima che venisse giocato con un normale pezzo di carta e una penna. Il gioco tradizionale cinese utilizza pietre bianche e nere.

In questo lavoro del corso Le regole di base e la dimensione standard del campo di gioco (3x3 celle) vengono preservate. Per comodità del gioco, all'utente è lasciato il diritto di fare la prima mossa, ovvero “croce”.

Tic Tac Toe è un programma progettato per intrattenere l'utente, quindi la sua interfaccia, in questo lavoro del corso, è realizzata in uno stile di gioco con una combinazione di colori positivi che aumentano la parte emotiva del processo di gioco.

Esistono tre tipi nel gioco: X contro 0 - utente contro utente, "1° livello con un computer" - per coloro che stanno appena imparando le basi del gioco mondiale e livello "2° livello con un computer" - per coloro che sono assolutamente fiduciosi della loro vittoria. Ai livelli 1 e 2 ci sono tre possibili risultati: “vittoria”, “perdita” e “pareggio”. Le vincite sono fisse se le linee verticali, orizzontali o diagonali sono completamente riempite con croci o zeri.

Se le celle libere del campo sono finite, ma nessuno vince, la partita viene considerata terminata con un “pareggio”.

1. ANALISI DEL PROBLEMA E DETERMINAZIONE DEI REQUISITI PER IL PROGRAMMA DA SVILUPPARE

interfaccia trasversale del programma

1.1 Scopo del programma, suoi utenti, principali funzioni e obiettivi perseguiti durante lo sviluppo

Lo scopo di questo programma è, prima di tutto, intrattenere gli utenti, rallegrare i tempi di attesa di una persona, perché qualsiasi lavoro richiede riposo, e questo semplice gioco ti aiuterà a rilassarti e a distogliere la mente dalle faccende quotidiane. "Tic Tac Toe" appartiene anche alla classe dei giochi intellettuali e logici, progettati per allenare il pensiero logico, consentire di concentrare l'attenzione e sviluppare la memoria.

Il pubblico target degli utenti sono i bambini, gli adolescenti e gli adulti. I criteri principali per l'utilizzo del prodotto sono la capacità di leggere il testo scritto nel programma e la capacità di selezionare l'attività necessaria per il computer utilizzando i pulsanti.

Da ciò possiamo concludere che i compiti principali sono: il compito di intrattenimento e il compito di sviluppare il potenziale logico di una persona.

1.2 Rassegna di programmi noti che svolgono funzioni simili

Su Internet puoi trovare un gran numero di lavori che implementano questo gioco. Attualmente, ci sono molti analoghi di questo gioco che si sono allontanati dagli standard originali. Un esempio di tali programmi sono "Tic-tac-toe su un campo infinito" e "Tic-tac-toe 3D". Inoltre, in molti giochi, le “croci” e le “dita dei piedi” vengono sostituite con altri simboli, come ad esempio le “pietre”.

Il progetto del mio corso è un'applicazione per PC. Il gioco è destinato sia a un utente, il cui avversario è l'intelligenza artificiale (o un computer), sia a due utenti. Si presenta su un classico campo 3x3.

Il più interessante e insolito, secondo me, è stato il gioco “Tic Tac Toe 3D”. Ecco perché l'ho scelto per il confronto.

Il tris 3D è molto più interessante che su carta o su una normale tavola. Ci sono più opportunità di vincere e perdere e i pareggi sono meno comuni. Puoi giocare da solo, contro il computer, o insieme a un amico. E la cosa più insolita qui è che per vincere, puoi creare una combinazione di tre palline del tuo colore (bianco o nero) non solo su qualsiasi livello, ma anche lungo il piano dei muri e persino in diagonale attraverso l'intero campo ( Figura 1.1).

Riso. 1.1

Tra l'ampia varietà di giochi su un argomento simile, possiamo evidenziare in ogni opera un'implementazione unica del piano. Ogni progetto differisce dagli altri nella sua individualità.

1.3 Basi teoriche dello sviluppo

Analisi

Per ciascuna delle parti esistono algoritmi ben noti che garantiscono il pareggio in qualsiasi partita dell'avversario e, se il suo avversario commette un errore, gli permettono di vincere. Quindi il gioco è in uno stato "nessuno muore"<#"877528.files/image002.gif">

Fig.1.2. Albero delle situazioni di gioco

Un albero parziale delle situazioni di gioco è mostrato in Fig. 1.2 per il gioco tris. Un albero di situazioni di gioco per il gioco del tris, dove il giocatore delle “croci” inizia per primo e agisce secondo l'algoritmo sopra, e il giocatore delle “punte” può fare quello che vuole (e un vertice è dato per un'azione razionale e per un'azione irrazionale, cioè qualsiasi altra), è composto da 50 nodi.

1.4 Selezione degli strumenti di sviluppo

Per raggiungere i nostri obiettivi, abbiamo bisogno di un ambiente di sviluppo applicativo integrato. Pertanto, lo sviluppo del progetto è stato effettuato nell'ambiente di programmazione Microsoft Visual Studio 2008.

Microsoft Visual Studio è una linea di prodotti Microsoft , compreso un ambiente di sviluppo integrato software e una serie di altri strumenti. Questi prodotti ti consentono di sviluppare come basato su console applicazioni e applicazioni GUI , incluso il supporto per la tecnologia Windows Forms , così come i siti web , servizi web come in nativo e controllato codici per tutte le piattaforme supportate da Windows , Windows Mobile ,Windows CE , .NETTO quadro , Xbox , Windows Phone .NET Framework compatto e Silverlight .

2. PARTE PROGETTUALE DELLO SVILUPPO

2.1 Sviluppo dell'interfaccia utente

Quando si crea un'applicazione di gioco, è necessario tenere conto di uno dei componenti principali del successo del prodotto: l'interfaccia. L'interfaccia utente del programma deve, prima di tutto, essere comprensibile e attraente per l'utente. Devi cercare di rimuovere tutti i momenti che distrarranno l'utente o gli causeranno disagio. L'intera interfaccia del programma può essere divisa in due componenti.

) Menù principale del programma

Riso. 2.1 - Menù principale del programma

Il menu principale è progettato per consentire all'utente di unirsi all'atmosfera di gioco, quindi l'interfaccia è progettata con colori colorati e giocosi. Attraverso il menu puoi andare sul campo di gioco, visualizzare le regole del gioco o uscire dal gioco.

) Campo da gioco

Fig 2.2 - Campo di gioco

Il campo di gioco contiene l'area di gioco immediata, dove il giocatore e il computer posizionano le loro icone. Prima di iniziare il gioco, l'utente deve selezionare il tipo di gioco come "X vs 0", "1 livello con computer" o "2 livelli con computer", altrimenti il programma darà un messaggio su cosa fare. Un pulsante che aiuterà il giocatore a tornare al menu principale. Al termine verranno visualizzate ulteriori finestre per informare il partecipante sui risultati della partita.

Riso. 2.3 - finestre aggiuntive sui risultati del gioco

2.2 Sviluppo delle strutture dati (in esterna e RAM)

La RAM viene utilizzata per un array unidimensionale composto da 9 elementi che memorizza gli stati del campo di gioco, dove ciascuna cella dell'array corrisponde a una cella sul campo di gioco. La memoria viene spesa anche su variabili statiche: numero di livello, ordine di turno.

Per funzionare richiede 803 KB di memoria libera.

.3 Sviluppo e analisi di algoritmi

Per implementare l'algoritmo di pensiero del gioco, è necessario specificare un array statico gcnew array (9); in cui verranno memorizzati gli stati del campo di gioco, dove ogni cella dell'array corrisponde ad una cella. “0” - corrisponde a una cella vuota, se un giocatore si è spostato nella cella, cioè “X”, viene registrato il valore “1” e se il computer ha effettuato una mossa, cioè “O”, il valore è “2”. Inizialmente tutti gli elementi dell'array sono uguali a "0". È necessario impostare la variabile statica lvl, che memorizza i dati di livello. Ci sono 3 livelli in totale in questo gioco: lvl assume il valore “1” se l'utente ha scelto il tipo di gioco “X vs O”, il valore “2” se “1° livello con un computer”, e il valore “3 ” se “2° livello con computer” " La variabile giocatore memorizza l’ordine del turno (“vero” è il turno del giocatore, “falso” è il turno del computer). Poiché il diritto di fare la prima mossa viene concesso all'utente, all'inizio del gioco player = true. La variabile statica flag memorizza informazioni sulla presenza o meno di celle vuote sul campo di gioco: se flag = true, ovvero false, non ci sono celle vuote. L'algoritmo di verifica deve contenere un'iterazione dei parametri dell'array x e proporre la propria soluzione, che sarà ottimale per il gioco successivo. Questo programma offre 2 livelli di gioco con un computer. Al livello 1, il compito del computer non è battere l'avversario. Ecco perché questa funzione restituisce un valore casuale della cella in cui andrà il computer. Il codice per questo algoritmo è presentato in [Appendice 1]. La Figura 2.4 mostra lo schema a blocchi dell'implementazione del codice.

La mossa più vincente all'inizio del gioco è spostarsi al centro del campo. Nella funzione dif_level(), all'inizio viene verificata una condizione: se il giocatore non è andato nel campo centrale, allora il computer va lì. Altrimenti, se il giocatore è andato al centro, viene richiamata la funzione check(2) per verificare la combinazione del computer e, se c'è un'opportunità di vincere, restituire il numero di cellulare. Se il computer non può vincere alla mossa successiva, viene chiamata la funzione check(1): controllare la combinazione del giocatore. Il numero della cella in cui il giocatore avrebbe vinto se avesse scommesso. Se non esiste tale combinazione, viene chiamata la funzione low_level().

Fig.2.4. - Diagramma a blocchi

Fig.2.5. - Diagramma a blocchi

3. IMPLEMENTAZIONE DEL PROGRAMMA IN LINGUAGGIO C++

.1 Architettura del programma

Questo programma implementa 3 moduli: il menu principale (Fig. 2.1.), il campo di gioco (Fig. 2.2) e il campo di aiuto (regole del gioco); 12 pannelli di cui 9 principali. Inoltre, alla fine del gioco, appare un pictureBox con il risultato, ce ne sono 5 in totale (Figura 2.3).

Puoi utilizzare come base i gestori dei clic del pannello, di cui ce ne sono esattamente 9 sul campo di gioco. Ogni gestore chiama diverse funzioni. All'inizio c'è una condizione, se l'utente seleziona il tipo di gioco “X contro 0”, le celle vengono semplicemente riempite con i valori 1 o 2 (croce o zero). Poi arrivano le funzioni: indicazione di avanzamento (CrossZero()), che cambia la croce in zero e viceversa, bloccando le celle occupate checkArray(), trovando il vincitore vincitore(). La funzione vincitore() considera tutte le possibili opzioni di vincita, quindi se uno dei giocatori allinea 3 dei suoi pezzi (una croce o uno zero) verticalmente, orizzontalmente o diagonalmente, vincerà. Altrimenti, se il campo è pieno, ma nessuno dei giocatori si è schierato, viene chiamata la funzione di pareggio (_friend()), che controlla se ci sono celle libere rimaste sul campo oppure no. Se fr = true, non ci sono celle libere sul campo. Se il valore è cambiato, significa che c'è una cella libera sul campo.

La seconda condizione funziona se viene selezionato il secondo o il terzo tipo di gioco. Quindi la funzione in cui è stata eseguita la mossa del computer si chiama: move(int n). Trasmette il numero della cella su cui il giocatore ha cliccato. Seguono le funzioni: indicazione dell'avanzamento (CrossZero()), blocco delle celle occupate CheckArray(). Successivamente viene richiamata la funzione winner(), che controlla se il giocatore ha vinto o meno con questa mossa. In caso contrario, viene verificata la presenza di celle libere. Se ci sono celle libere, il computer si muove. Successivamente, a seconda del livello scelto dal giocatore “1” o “2”, vengono chiamate le seguenti funzioni: low_level(), dif_level(). La funzione low_level() seleziona dove posizionare lo zero in modo casuale e la funzione dif_level() presenta un algoritmo speciale per far vincere il computer. Seguono le funzioni: indicazione dell'avanzamento (CrossZero()), blocco delle celle occupate CheckArray(). Successivamente viene richiamata la funzione winner(), che controlla se il computer ha vinto o meno con questa mossa. In caso contrario, viene verificata la presenza di celle libere. Se ci sono celle libere, il giocatore si muove.

.2 Selezione di componenti visivi e non visivi standard

Per implementare questo lavoro, sono stati selezionati i seguenti componenti:

1) Modulo1, con parametri dati Testo=Tic-Tac-Toe, ControlBox=False

2) f2, con i parametri specificati BackColor, Text=Game

) comboBox1 con i parametri Articoli specificati:

X contro 0

1° livello con computer

Livello 2 con computer

4) pannello, con parametri BackColor specificati, e valori diversi per i parametri Visible e Enabled. Per alcuni pannelli sono stati scritti eventi come Click.

5) pulsante, con i parametri specificati Font, Colore primo piano, Colore sfondo, Testo, per tutti i pulsanti sono stati scritti eventi come Click.

6) etichetta, con i parametri specificati BackColor, Font, Fore Color, Text.

) pictureBox, con i parametri specificati Image, SizeMode= StretchImage.

) textBox, con i parametri specificati BackColor, Font, Fore Color, Text=" ".

4. RISULTATI DEL TEST

Testiamo il programma esaminando 3 tipi di giochi.

Proviamo le azioni dei pulsanti del menu principale. I pulsanti funzionano correttamente. Proviamo ad avviare il gioco senza scegliere un tipo di gioco. Il programma visualizza un messaggio di errore e chiede di selezionare il tipo di gioco (Fig. 4.1).

Fig.4.1.

Scegliamo 1 tipo di gioco: "X contro 0", ad es. utente contro utente. In questa fase del gioco l'utente può anche giocare con se stesso. (Fig.4.2)

Fig.4.2.

Durante il gioco “Livello 1 con il computer” il computer non si pone l'obiettivo di vincere il partecipante. Inserisce solo degli zeri posti liberi campi. In questa fase, l'utente può facilmente battere il computer. Sebbene a questo livello siano possibili anche altre opzioni per lo sviluppo di eventi.

Fig.4.3.

Tipo di gioco: “Livello 2 con computer”. In questa fase, il gioco analizza tutte le mosse e cerca di scegliere quella più ottimale. Anche qui tutti e tre gli scenari sono possibili, perché Il computer fa la sua prima mossa su qualsiasi cella libera. Molto spesso la partita finisce in pareggio.

Fig.4.4.

Il programma funziona con successo su tutte le varianti di test, senza errori.

CONCLUSIONE

Possiamo dire con sicurezza che il compito fissato all'inizio dei lavori è stato portato a termine. Durante lo sviluppo è stato pianificato e sviluppato un progetto per un remix del famoso gioco “Tic Tac Toe”. Il gioco soddisfa i requisiti specificati e svolge le sue funzioni. Implementato nel lavoro Vari tipi giochi e livelli di difficoltà.

Durante il lavoro, sono stati padroneggiati nuovi metodi di programmazione in un ambiente di sviluppo integrato. Le vecchie conoscenze sull'utilizzo del linguaggio C++ sono state consolidate. In preparazione al lavoro del corso, sono stati analizzati vari metodi e algoritmi per l'implementazione di questo gioco.

Nonostante l'apparente semplicità di questo programma, è irto di una serie di difficoltà che vengono implementate utilizzando tutte le tecniche di base di Visual C++.

Le caratteristiche di questo programma sono:

Algoritmo chiaramente costruito;

Interfaccia intuitiva;

Facile da usare;

Manuale utente abbastanza chiaro;

Nessun componente aggiuntivo non necessario.

BIBLIOGRAFIA

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

ALLEGATO 1

private: int low_level())(// procedura per un avversario leggero;::Random^ rand = gcnew System::Random();(= rand->Next(0,8);

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

APPENDICE 2

private: bool check(int n)(k = -1;// controlla tutte le combinazioni e restituisce la mossa corretta(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) restituisce vero; altrimenti restituisce falso;

APPENDICE 3

privato: int dif_level())(//nemico difficile

//restituisce controllo(2);(x == 0) ritorno (4);(controllo(2)) ritorno k; altrimenti (controlla(1)) return k; altrimenti livello_basso();

APPLICAZIONE 4

private: void CrossZero())(// cambia la croce in uno zero (indicatore di avanzamento)(giocatore) (->Visible = true;->Visible = false;

) altrimenti (->Visibile = vero;->Visibile = falso;

): void CheckArray())(// funzione per verificare se c'è qualcosa in una cella, se c'è, non è più possibile fare clic su questa cella.(x == 1) (panel1->BackgroundImage = panel11->BackgroundImage ;pannello1- >Abilitato = false;)(x == 2) (pannello1->BackgroundImage = pannello10->BackgroundImage;pannello1->Abilitato = false;)(x == 1) (panel2->BackgroundImage = pannello11->BackgroundImage ;pannello2- >Abilitato = false;)(x == 2) (pannello2->BackgroundImage = pannello10->BackgroundImage;pannello2->Abilitato = false;)(x == 1) (panel3->BackgroundImage = pannello11->BackgroundImage ;panel3- >Abilitato = false;)(x == 2) (panel3->BackgroundImage = pannello10->BackgroundImage;panel3->Abilitato = false;)(x == 1) (panel4->BackgroundImage = pannello11->BackgroundImage ;panel4- >Abilitato = false;)(x == 2) (panel4->BackgroundImage = pannello10->BackgroundImage;panel4->Abilitato = false;)(x == 1) (panel5->BackgroundImage = pannello11->BackgroundImage ;panel5- >Abilitato = false;)(x == 2) (panel5->BackgroundImage = pannello10->BackgroundImage;panel5->Abilitato = false;)(x == 1) (panel6->BackgroundImage = pannello11->BackgroundImage ;panel6- >Abilitato = false;)(x == 2) (panel6->BackgroundImage = pannello10->BackgroundImage;panel6->Abilitato = false;)(x == 1) (panel7->BackgroundImage = pannello11->BackgroundImage ;panel7- >Abilitato = false;)(x == 2) (panel7->BackgroundImage = pannello10->BackgroundImage;panel7->Abilitato = false;)(x == 1) (panel8->BackgroundImage = pannello11->BackgroundImage ;panel8- >Abilitato = false;)(x == 2) (panel8->BackgroundImage = pannello10->BackgroundImage;panel8->Abilitato = false;)(x == 1) (panel9->BackgroundImage = pannello11->BackgroundImage ;panel9- >Abilitato = false;)(x == 2) (panel9->BackgroundImage = panel10->BackgroundImage;panel9->Abilitato = false;)

): bool vincitore())(// controlla il vincitore e blocca tutte le celle rimanenti.

//flag bool = 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) (immaginePo->Visibile = vero;)(immaginePr->Visibile = vero;)->Abilitato = falso;->Abilitato = falso;->Abilitato = falso;->Abilitato = falso;-> Abilitato = falso;->Abilitato = falso;->Abilitato = falso;->Abilitato = falso;->Abilitato = falso;vero;

)(((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;)->Abilitato = false;->Abilitato = false;->Abilitato = false;->Abilitato = false;->Abilitato = false;-> Abilitato = falso;->Abilitato = falso;->Abilitato = falso;->Abilitato = falso;vero;

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

): void move(int n)(// funzione di spostamento del computer= false;[n] = 1;= !giocatore;();();(vincitore()) () ((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) (// nuovo gioco>Visible = false;>Visible = false;>Visible = false; >Visible = false; >Visible = false; = comboBox1->Text;(typeGame == "")(::Show("Seleziona prima il tipo di gioco!");

) else ((typeGame == "X contro 0") lvl = 1;(typeGame == "1° livello con un computer") lvl = 2;(typeGame == "2° livello con un computer") lvl = 3;( ); = vero;(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 = pannello12->BackgroundImage;->BackgroundImage = pannello12->BackgroundImage;->BackgroundImage = pannello12->BackgroundImage;->Abilitato = vero;->Abilitato = vero;->Abilitato = vero;->Abilitato = vero;->Abilitato = vero;->Abilitato = vero;->Abilitato = vero;->Abilitato = vero;->Abilitato = vero;

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

)= !giocatore;();();();

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

)= !giocatore;();();();