AI не играет хорошо в вертикальной крестики-нолики c #

Question

Я играю в крестики-нолики с ИИ. ИИ играет хорошо, за исключением , когда он должен выиграть с вертикалью . Все остальные способы (горизонтальные и диагональные) работают .

Я сделал много отладок и шаг за шагом и не нашел решения. Я думал, что вы, ребята, могли бы помочь мне найти проблему и помочь мне решить ее!

  int findTwoPions(Boolean?[,] jeu)
    {

        // La méthode qui selon moi est à modifier car c'est celle ci qui décide la position que doit prendre l'IA quand elle peu gagner

        int somme = 0;
        int compteurX = 0;
        int compteur0 = 0;

        //Diagonale descendante
        for (int i = 0; i < 3; i++)
        {
            if ((jeu[0, 0] == false || jeu[1, 1] == false || jeu[2, 2] == false) && (jeu[0, 0] == true || jeu[1, 1] == true || jeu[2, 2] == true))
            {
                somme += 0;
            }
            else
            {
                if (jeu[i, i] == false)
                {
                    compteur0++;
                    compteurX = 0;
                    if (compteur0 == 2)
                    {
                        somme += 1500;
                    }
                }
                else if (jeu[i, i] == true)
                {
                    compteur0 = 0;
                    compteurX++;
                    if (compteurX == 2)
                    {
                        somme -= 1600;
                    }
                }
            }
        }

        compteurX = 0;
        compteur0 = 0;

        //Diagonale montante
        for (int i = 0; i < 3; i++)
        {
            if ((jeu[0, 2] == false || jeu[1, 1] == false || jeu[2, 0] == false) && (jeu[0, 2] == true || jeu[1, 1] == true || jeu[2, 0] == true))
            {
            }
            else
            {
                if (jeu[i, 2 - i] == false)
                {
                    compteur0++;
                    compteurX = 0;
                    if (compteur0 == 2)
                    {
                        somme += 1500;
                    }
                }
                else if (jeu[i, 2 - i] == true)
                {
                    compteurX++;
                    compteur0 = 0;
                    if (compteurX == 2)
                    {
                        somme -= 1600;
                    }
                }
            }
        }

        //En ligne
        for (int i = 0; i < 3; i++)
        {
            compteurX = 0;
            compteur0 = 0;

            if ((jeu[0, i] == false || jeu[1, i] == false || jeu[2, i] == false) && (jeu[0, i] == true || jeu[1, i] == true || jeu[2, i] == true))
            {
                somme += 0;
            }
            else
            {
                //Verticale
                for (int j = 0; j < 3; j++)
                {

                    if (jeu[j, i] == false)
                    {
                        compteur0++;
                        compteurX = 0;
                        if (compteur0 == 2)
                        {
                            somme += 1500;
                        }
                    }
                    else if (jeu[j, i] == true)
                    {
                        compteurX++;
                        compteur0 = 0;
                        if (compteurX == 2)
                        {
                            somme -= 1600;

                        }
                    }

                }
            }

            compteurX = 0;
            compteur0 = 0;

            if ((jeu[i, 0] == false || jeu[i, 1] == false || jeu[i, 2] == false) && (jeu[i, 0] == true || jeu[i, 1] == true || jeu[i, 2] == true))
            {
                return somme += 0;
            } // Voir les valeurs i j pcque c'est faux 
            else
            {
                //Horizontale
                for (int j = 0; j < 3; j++)
                {

                    if (jeu[i, j] == false)
                    {
                        compteur0++;
                        compteurX = 0;
                        if (compteur0 == 2)
                        {
                            somme += 1500;
                        }
                    }
                    else if (jeu[i, j] == true)
                    {
                        compteurX++;
                        compteur0 = 0;
                        if (compteurX == 2)
                        {
                            somme -= 1600;
                        }
                    }

                }
            }
        }

        return somme;
    }

}

}

Я думаю, что проблема в том, когда я добавляю значение к 'somme' или как я бегу через крестики-нолики. Если вам нужен дополнительный код, пожалуйста, скажите мне, спасибо!

UPDATE:

MY AIRoutine.cs

public Boolean?[][] IAPlay(Boolean?[][] jeu, int profondeur)
    {

        int max = -10000;
        int tmp, tmp2 = 0, tmpSomme = -10000; // -10000
        int tmpBefore = 0;
        int maxi = 0, maxj = 0;
        int somme = 0;
        int biggestSomme = 0;

        setTab(jeu); // convertit le tableau[][] en tableau[,]

        for (int i = 0; i < 3; i++) // parcours toutes les cases vides du tableau
        {
            for (int j = 0; j < 3; j++)
            {
                //Si une case est vide, on joue le coup de l'IA sur cette case et on simule le jeu complet
                if (tab[i, j] == null)
                {
                    tab[i, j] = false; // On simule le coup de l'IA
                    somme = findTwoPions(tab);
                    tmp = Max(tab, profondeur - 1);



                    if (tmpBefore < tmp && biggestSomme > somme)
                    {
                        tmpSomme = somme + tmpBefore;
                    }
                    else if (tmpBefore > tmp && biggestSomme < somme)
                    {
                        tmpSomme = somme + tmpBefore;
                    }
                    else
                    {
                        tmpSomme = tmp + somme;
                    }

                    if (somme > biggestSomme)
                    {
                        biggestSomme = somme;
                        tmpBefore = tmp;
                    }

                    //|| ((tmp == max) && (r.Next(1, 100) % 2 == 0))
                    if (tmpSomme >= max)
                    {
                        max = tmpSomme;
                        tmp2 = somme;
                        maxi = i;
                        maxj = j;
                    }
                    tab[i, j] = null;
                }
            }
        }

        tab[maxi, maxj] = false;
        return getTab(jeu);
    }

Answer 1

Давайте поместим его в для чтения и keepabe способом: давайте извлечем метод WinningLines, где мы перечисляем все выигрышные комбинации ( Я предположил, что jue это 2d массив - bool?[3, 3]):

    using System.Linq;

    ... 

    private static IEnumerable<bool?[]> WinningLines(bool?[,] field) {
      // Verticals
      for (int column = 0; column < 3; ++column)
        yield return new bool?[] {field[0, column], field[1, column], field[2, column]};

      // Horizontals
      for (int row = 0; row < 3; ++row)
        yield return new bool?[] {field[row, 0], field[row, 1], field[row, 2]};

      // Diagonals 
      yield return new bool?[] {field[0, 0], field[1, 1], field[2, 2]};
      yield return new bool?[] {field[0, 2], field[1, 1], field[2, 0]};
    }

Теперь давайте запрос (с помощью Linq ):

  // Do we have any winning combinations for the 1st Player (all 3 true in WinningLines):
  bool hasFirstWon = WinningLines(jeu).Any(line => line.All(cell => cell == true));

  // Do we have any winning combinations for the 2nd Player (all 3 false in WinningLines): 
  bool hasSecondWon = WinningLines(jeu).Any(line => line.All(cell => cell == false));

Или если вы работаете с somme:

  int somme = 
      WinningLines(jeu).Any(line => line.All(cell => cell == true)) ?  
        1500 // 1st wins
    : WinningLines(jeu).Any(line => line.All(cell => cell == false)) ? 
       -1600 // 2nd wins 
    : 0;     // no-one wins

Редактировать: Теперь давайте реализуем (простую) версию метода int findTwoPions(Boolean?[,] jeu). Сначала давайте

private static bool FirstIsOnMove(bool?[,] field) {
  int count = 0;

  foreach (var item in field)
    if (item == true)
      count += 1;
    else if (item == true)
      count -= 1;

  return count == 0;
} 

и сам метод будет

 // This method rates the position in a [-1600..1500] range 
 // [1st player has lost..1st player has won]
 int findTwoPions(Boolean?[,] jeu) {
   // Edge cases: win or lose
   if (WinningLines(jeu).Any(line => line.All(cell => cell == true)))
     return 1500;  // 1st has won 
   else if (WinningLines(jeu).Any(line => line.All(cell => cell == false))) 
     return -1600; // 1st has lost 

   //TODO: add more heuristics (depending who is on move)

   // Example: if palayer is on move and can win by its next move? 
   // Say, we have positions like
   //   X..           XXO          
   //   OX.    Or     X.O
   //   .O.           ...
   if (FirstIsOnMove(jeu)) { 
     if (WinningLines(jeu)
       .Any(line => line.Sum(item => item == true ? 1 : item == false ? -1 : 0) == 2))
         return 1200; // 1st is going to win (unless it makes a blind)
   }
   else {
     if (WinningLines(jeu)
       .Any(line => line.Sum(item => item == true ? 1 : item == false ? -1 : 0) == -2))
         return -1200; // 2st is going to win (unless it makes a blind) 
   }

   // Neutral position - neither 1st not 2nd have any advantages 
   return 0;
 }