Amélioration de la fonction d'évaluation dans le jeu tic-tac-toe - algorithme alpha-beta

Question

Je cherche une fonction d'évaluation optimale à utiliser dans l'algorithme minimax/alpha-beta pour développer l'IA tic-tac-toe. Je compte le nombre de cercles/croix dans une ligne/colonne/diagonale avec un espace vide derrière (avec un rang de trois, il n'y a pas d'espace vide). Sur la base du nombre de symboles dans une telle ligne, je multiplie les scores séparés par 10^(compteur-1), ce qui donne 1,10 ou 100 points.

Je suis sûr que beaucoup peut être amélioré, parce que la solution optimale est rarement trouvée et j'ai des problèmes en utilisant cette fonction dans l'algorithme alphabeta

Ma question est - Comment cette fonction peut-elle être améliorée? Petits morceaux de code et suggestions appréciés.

Mon code:

private int h(int[][] field, int depth, int player) //final score of the node 
     { 
      if (win(field, 1)) //if human won 
       return -1000; //very bad for MAX=computer 
      if (win(field, 0)) //if computer won 
       return 1000; 

      int heuristics = individualScore(field, 0) - individualScore(field, 1); 
      return heuristics; 
     } 

private int individualScore(int[][] field, int player) 
     { 

      int sum = 0; 
      int otherPlayer = -1; 
      if (player == 0) //if computer is the current player 
       otherPlayer = 1; //other player is human 
      else 
       otherPlayer = 0;//Vice versa 
      for (int i = 0; i < 3; i++) // rows 
      { 
       int counter = 0; 
       bool rowAvailable = true; 
       for (int l = 0; l < 3; l++) 
       { 
        if (field[i][l] == player) 
         counter++; 
        if (field[i][l] == otherPlayer) 
        { 
         rowAvailable = false; 
         break; 
        } 
       } 
       if (rowAvailable && counter > 0) 
        sum += (int)Math.Pow(10, counter - 1); 
      } 

      for (int i = 0; i < 3; i++) // columns 
      { 
       int counter = 0; 
       bool columnAvailable = true; 
       for (int k = 0; k < 3; k++) 
       { 
        if (field[k][i] == player) 
         counter++; 
        if (field[k][i] == otherPlayer) 
        { 
         columnAvailable = false; 
         break; 
        } 
       } 
       if (columnAvailable && counter > 0) 
        sum += (int)Math.Pow(10, counter - 1); 
      } 
      int counterD = 0; 
      bool diagonalAvailable = true; 
      for (int i = 0; i < 3; i++) //diagonals 
      { 
       if (field[i][i] == player) 
        counterD++; 
       if (field[i][i] == otherPlayer) 
       { 
        diagonalAvailable = false; 
        break; 
       } 
      } 
      if (diagonalAvailable && counterD > 0) 
       sum += (int)Math.Pow(10, counterD - 1); 
      counterD = 0; 
      diagonalAvailable = true; 
      int j = 0; 
      for (int i = 2; i >= 0; i--) 
      { 
       if (field[i][j] == player) 
        counterD++; 
       if (field[i][j] == otherPlayer) 
       { 
        diagonalAvailable = false; 
        break; 
       } 
      } 
      if (diagonalAvailable && counterD > 0) 
       sum += (int)Math.Pow(10, counterD - 1); 

      return sum; 
     } 

Answer 1

Vous pouvez laisser votre AI regarder en avant un ou même deux étapes, pour que vous puissiez voir quelles sont les chances de l'utilisateur (et l'AI à nouveau) a après l'AI a son étape (et évaluer cette chance à nouveau). En outre, vous pouvez ajouter quelques trucs, de sorte que l'IA tente de tromper l'utilisateur dans des situations, il ne peut pas sortir. Ceci est possible en raison du fait qu'il n'y a pas beaucoup de possibilités dans Tic-Tac-Toe.

Si vous voulez être vraiment cool, vous pouvez créer un réseau de neurones, qui apprend de certains jeux que vous jouez avec, mais c'est une histoire totalement différente.