需要帮助找到我的井字游戏极小极大算法中的问题

Question

一段时间以来，我一直在构建我的井字游戏项目，并且一直遇到使用 minimax 实现无与伦比的 AI 的问题。

我现在处于游戏几乎完全正常运行的地步，只是我在网格上有一个特定的正方形没有按预期工作。 如中所示，它似乎解释了数组中除了索引 [8] 处的正方形之外的所有结果。 它似乎避免将自己放在那里或从中计算正确的结果。

    const gameBoard = (() => {
        //stores current gameboard as an array
        let array = ['','','','','','','','',''];
        let currentPlayer;
      
        //clears the gameBoard display
        button.addEventListener('click', () => {
          clearDisplay();
        });
      
        //game display that renders the contents of array to gameboard
        const display = (index, name) => {
          //renders players click to the board, taking in the index of the square
          gameBoard.array.splice(index, 1, name.team);
          innerAnswerText[index].innerText = gameBoard.array[index];
        }
        
        //clears the array and display
        const clearDisplay = () => {
          gameBoard.array = ['','','','','','','','',''];
          innerAnswerText.forEach(text => text.innerText = '');
        }
  
      
        return { display, array, clearDisplay, currentPlayer }
    })();


    //contains all of our game logic
    const game = (() => {    
                
        //starts our game and controls the flow of player vs ai
        const startGame = (index) => {
          //game display that takes in the players click index and renders the             contents of array to gameboard
          gameBoard.display(index, ryan);  
          gameBoard.currentPlayer = 'X';
          if (checkWinner(gameBoard.currentPlayer) !== null) {
            console.log(gameBoard.currentPlayer + ' has won the round!');
            return;
          }
          //computers turn that takes a random choice from the indexes that are           empty and prints it to the board
          
          let compMove;
          let bestScore = -Infinity;
          gameBoard.array.forEach((item,i) => {
            if (gameBoard.array[i] == '') {
              gameBoard.array[i] = 'O';
              let score = minimax(gameBoard.array, 0, false);
              gameBoard.array[i] = '';
              if (score > bestScore) {
                bestScore = score;
                compMove = i;
              }
            }
          });
          gameBoard.display(compMove, computer);
          gameBoard.currentPlayer = 'O';
          if (checkWinner(gameBoard.currentPlayer) !== null) {
            console.log(gameBoard.currentPlayer + ' has won the round!');
            return;
          }
        }
        
        //loop through our html boxes and apply event listeners to each square that will initiate the players round

        boxes.forEach((square, i) => {
          square.onclick = () => {
            startGame(i);
          }
        });   
        
        //checks for a win or a tie using current player variable to check whose turn it is

        const checkWinner = (player) => {
          let winner = null;
          let a = gameBoard.array;
          
          let openSpaces = 0;
          //horizontal win check
          if (a[0] == player && a[1] == player && a[2] == player) {
            winner = player;
          }
          if (a[3] == player && a[4] == player && a[5] == player) {
            winner = player;
          }
          if (a[6] == player && a[7] == player && a[8] == player) {
            winner = player;
          }
          
          //vertical win check
          if (a[0] == player && a[3] == player && a[6] == player) {
            winner = player;
          }
          if (a[1] == player && a[4] == player && a[7] == player) {
            winner = player;
          }
          if (a[2] == player && a[5] == player && a[8] == player) {
            winner = player;
          }
          
          //diagonal win check
          if (a[0] == player && a[4] == player && a[8] == player) {
            winner = player;
          }
          if (a[2] == player && a[4] == player && a[6] == player) {
            winner = player;
          }
          
          for (let i=0; i < 8; i++) {
            if (gameBoard.array[i] == '') {
              openSpaces++;
            }
          }
          
          if (winner == null && openSpaces == 0) {
            return 'tie';
          }

          return winner;
        }
          
          let scores = {
            X: -10,
            O: 10,
            tie: 0
          }
          
          const minimax = (board, depth, maximizingPlayer) => {
            let result = checkWinner(gameBoard.currentPlayer);
            
            if (result !== null) {
              return scores[result];
            }
            
            if (maximizingPlayer) {
              let bestScore = -Infinity;
              for (let i = 0; i < 8; i++) {
              
                if (board[i] == '') {
                  board[i] = 'X';
                  let score = minimax(board, depth + 1, false);
                  board[i] = '';
                  bestScore = Math.max(score, bestScore);
                }
              }
              return bestScore;

            } else {
                let bestScore = Infinity;
                for (let i = 0; i < 8; i++) {
                  if (board[i] == '') {
                    board[i] = 'O';
                    let score = minimax(board, depth + 1, true);
                    board[i] = '';
                    bestScore = Math.min(score, bestScore);
                  }
                }
    
                return bestScore;
            }
          }
    
        
        return { startGame, checkWinner }

        
        
      })();

        //factory function that produces our player object taking in name and team
    const player = (name, team) => {
        
        return { name, team };
    }
    
    const ryan = player('ryan', 'X');
    const computer = player('computer', 'O');
  
  
  
})();

我知道这里有很多代码，我认为问题出在我们的 for each 或 minimax 递归内的循环周围，但我不确定。 我将在下面提供我的代码笔，这样您就可以看到实际的游戏正在运行，并且您会明白我所说的第 9 格没有按预期运行的意思。

https://codepen.io/itswakana/pen/gOeMrym?editors=1111

感谢您提供的任何帮助！ 谢谢。

Answer 1

在您的 Minimax 函数中，您for (let i = 0; i < 8; i++) {在两个地方编写。 那 8 不应该是 9，还是放一个 <= 而不是 <？ 现在您只是检查索引 0 到 7，即前 8 个方块。