Vérification du vainqueur dans TicTacToe?

Question

Quel serait le meilleur moyen de voir (dans un 2 joueurs) le jeu de Tic Tac Toe qui a gagné? En ce moment j'emploie quelque chose semblable au suivant:

if (btnOne.Text == "X" && btnTwo.Text == "X" && btnThree.Text == "X") 
{ 
    MessageBox.Show("X has won!", "X won!"); 
    return; 
} 
else 
// I'm not going to write the rest but it's really just a bunch 
// if statements. 

Ainsi comment je me débarrasse du multiple si?

Answer 1

alongs Quelque chose:

rowSum == 3 || columnSum == 3 || diagnolSum == 3 

..?

Answer 2

Une autre façon simple sortir serait d'enregistrer les positions gagnables en tant que données dans un tableau et utiliser une boucle pour vérifier toutes les conditions gagnantes possibles au lieu de plusieurs déclarations ifs

// winnable positions 
var winnables = new[] { 
    "012", 
    "345", 
    "678", 
    "036", 
    "147", 
    "258", 
    "048", 
    "246" 
}; 

// extracted from btnOne Two Three.... 
var gameState = new[] { "X", "O", "X", "whatever" }; 


string winner = null; 

// check each winnable positions 
foreach (var position in winnables) { 

    var pos1 = int.Parse(position[0].ToString()); 
    var pos2 = int.Parse(position[1].ToString()); 
    var pos3 = int.Parse(position[2].ToString()); 

    if (gameState[pos1] == gameState[pos2] && 
     gameState[pos2] == gameState[pos3]) 
     winner = gameState[pos1]; 

} 

// do we have a winner? 
if (!string.IsNullOrEmpty(winner)) 
    /* we've got a winner */ 

En gros, ne pas utiliser btnOne btnTwo btnThree, utilisez un tableau approprié de boutons ou un tableau qui enregistre l'état du jeu dans un format plus accessible et il sera plus facile à calculer.

Answer 3

Si vous stockez vos boutons dans un tableau multidimensionnel, vous pouvez écrire des méthodes d'extension pour obtenir les lignes, les colonnes et les diagonales.

public static class MultiDimensionalArrayExtensions 
{ 
    public static IEnumerable<T> Row<T>(this T[,] array, int row) 
    { 
    var columnLower = array.GetLowerBound(1); 
    var columnUpper = array.GetUpperBound(1); 

    for (int i = columnLower; i <= columnUpper; i++) 
    { 
     yield return array[row, i]; 
    } 
    } 

    public static IEnumerable<T> Column<T>(this T[,] array, int column) 
    { 
    var rowLower = array.GetLowerBound(0); 
    var rowUpper = array.GetUpperBound(0); 

    for (int i = rowLower; i <= rowUpper; i++) 
    { 
     yield return array[i, column]; 
    } 
    } 

    public static IEnumerable<T> Diagonal<T>(this T[,] array, 
              DiagonalDirection direction) 
    { 
    var rowLower = array.GetLowerBound(0); 
    var rowUpper = array.GetUpperBound(0); 
    var columnLower = array.GetLowerBound(1); 
    var columnUpper = array.GetUpperBound(1); 

    for (int row = rowLower, column = columnLower; 
     row <= rowUpper && column <= columnUpper; 
     row++, column++) 
    { 
     int realColumn = column; 
     if (direction == DiagonalDirection.DownLeft) 
     realColumn = columnUpper - columnLower - column; 

     yield return array[row, realColumn]; 
    } 
    } 

    public enum DiagonalDirection 
    { 
    DownRight, 
    DownLeft 
    } 
} 

Et si vous utilisez un TableLayoutPanel avec 3 lignes et 3 colonnes, vous pouvez facilement créer vos boutons et le stocker de manière programmable dans un tableau Button[3, 3].

Button[,] gameButtons = new Button[3, 3]; 

for (int row = 0; column <= 3; row++) 
    for (int column = 0; column <= 3; column++) 
    { 
    Button button = new Button(); 
    // button... 
    gameLayoutPanel.Items.Add(button); 
    gameButtons[row, column] = button; 
    } 

Et pour vérifier un gagnant:

string player = "X"; 
Func<Button, bool> playerWin = b => b.Value == player; 
gameButtons.Row(0).All(playerWin) || 
// ... 
gameButtons.Column(0).All(playerWin) || 
// ... 
gameButtons.Diagonal(DiagonalDirection.DownRight).All(playerWin) || 
// ...