JAVA Tic-Tac-Toe Minimax算法不断引发异常

我正在尝试用minimax算法做一个tic-tac-toe游戏。我正在用这个。虽然我理解这个算法是如何工作的，但我在实现它时遇到了困难。我无法让这个算法通过单元测试。这给了我一个例外，就是电路板上的单元被占用，我自己找不到解决方案。它应该返回板中的获胜指数。谢谢你的帮助

以下是失败的测试响应：

exceptions.CellIsNotAvailableException: This cell is occupied.

at board.Cell.setMarker(Cell.java:22)
at algorithm.Algorithm.minimax(Algorithm.java:204)
at algorithm.Algorithm.findBestMove(Algorithm.java:217)
at tgrevious.boardTest.BoardTest.shouldreturneight(BoardTest.java:71)

失败的单元测试：

@Test
public void shouldreturneight() {
    GameBoard gameBoard = new GameBoard();
    Algorithm al = new Algorithm();
    gameBoard.addMarkerToCell(0,Token.X);
    gameBoard.addMarkerToCell(1,Token.O);
    gameBoard.addMarkerToCell(2,Token.X);
    gameBoard.addMarkerToCell(3,Token.O);
    gameBoard.addMarkerToCell(4,Token.O);
    gameBoard.addMarkerToCell(5,Token.X);
    //gameBoard.addMarkerToCell(2,Token.X);
    int bestMove = al.findBestMove(gameBoard.getBoard());
    assertEquals(8, bestMove);
}

我抛出的异常：

public class CellIsNotAvailableException extends IllegalArgumentException {

public CellIsNotAvailableException(String message) {
    super(message);
}

}

算法类

public class Algorithm {
    public boolean checkRows(Cell[] board) {
    if ((board[0].getMarker() == board[1].getMarker() && board[1].getMarker() == board[2].getMarker()) ||
       (board[3].getMarker() == board[4].getMarker() && board[4].getMarker() == board[5].getMarker()) ||
       (board[6].getMarker() == board[7].getMarker() && board[7].getMarker() == board[8].getMarker())) {
       return true;
    }
    return false;
}

public boolean checkColumns(Cell[] board) {
    if ((board[0].getMarker() == board[3].getMarker() && board[3].getMarker() == board[6].getMarker()) ||
        (board[1].getMarker() == board[4].getMarker() && board[4].getMarker() == board[7].getMarker()) ||
        (board[2].getMarker() == board[5].getMarker() && board[5].getMarker() == board[8].getMarker())) {
        return true;
    }
    return false;
}

public boolean checkdiagonals(Cell[] board) {
    if ((board[0].getMarker() == board[4].getMarker() && board[4].getMarker() == board[8].getMarker()) ||
            (board[2].getMarker() == board[4].getMarker() && board[4].getMarker() == board[6].getMarker())) {
        return true;
    }
    return false;
}

Token botPlayer = Token.X;
Token opponent = Token.O;

public int evaluate(Cell[] board) {
    //rows across
    if ((board[0].getMarker() == board[1].getMarker() && board[1].getMarker() == board[2].getMarker())) {
        if (board[0].getMarker() == Token.X) {
            return 10;
        }
        else if (board[0].getMarker() == Token.O) {
            return -10;
        }
    }
    if (board[3].getMarker() == board[4].getMarker() && board[4].getMarker() == board[5].getMarker()) {
        if (board[3].getMarker() == Token.X) {
            return 10;
        }
        else if (board[3].getMarker() == Token.O) {
            return -10;
        }
    }
    if (board[6].getMarker() == board[7].getMarker() && board[7].getMarker() == board[8].getMarker()) {
        if (board[6].getMarker() == Token.X) {
            return 10;
        }
        else if (board[6].getMarker() == Token.O) {
            return -10;
        }
    }
    //columns down
    if (board[0].getMarker() == board[3].getMarker() && board[3].getMarker() == board[6].getMarker()) {
        if (board[0].getMarker() == Token.X) {
            return 10;
        }
        else if (board[0].getMarker() == Token.O) {
            return -10;
        }
    }
    if (board[1].getMarker() == board[4].getMarker() && board[4].getMarker() == board[7].getMarker()) {
        if (board[1].getMarker() == Token.X) {
            return 10;
        }
        else if (board[1].getMarker() == Token.O) {
            return -10;
        }
    }
    if (board[2].getMarker() == board[5].getMarker() && board[5].getMarker() == board[8].getMarker()) {
        if (board[2].getMarker() == Token.X) {
            return 10;
        }
        else if (board[2].getMarker() == Token.O) {
            return -10;
        }
    }
    //rows diagonally
    if (board[0].getMarker() == board[4].getMarker() && board[4].getMarker() == board[8].getMarker()) {
        if (board[0].getMarker() == Token.X) {
            return 10;
        }
        else if (board[0].getMarker() == Token.O) {
            return -10;
        }
    }
    if (board[2].getMarker() == board[4].getMarker() && board[4].getMarker() == board[6].getMarker()) {
        if (board[2].getMarker() == Token.X) {
            return 10;
        }
        else if (board[2].getMarker() == Token.O) {
            return -10;
        }
    }
    return 0;
}

public boolean hasCellsLeft(Cell[] board) {
    for (int i=0; i<9; i++) {
        if (board[i].getMarker() == Token.EMPTY) {
            return true;
        }
    }
    return false;
}

public int minimax(Cell[] board,  int depth, boolean isMax) {
    int score = evaluate(board);
    int best;
    //if maximizer won
    if (score == 10) {
        return score;
    }
    //if minimizer won
    if (score == -10) {
        return score;
    }
    if (hasCellsLeft(board) == false) {
        return 0;
    }
    if (isMax) {
        best = -1000;
        for (int i=0; i<board.length; i++) {
            if (board[i].getMarker() == Token.EMPTY) {
                board[i].setMarker(botPlayer);
                best = Math.max(best, minimax(board, depth+1, !isMax));
                board[i].setMarker(Token.EMPTY);
            }
        }
        return best;
    }
    else {
        best = 1000;
        for (int i=0; i<board.length; i++) {
            if (board[i].getMarker() == Token.EMPTY) {
                board[i].setMarker(opponent);
                best = Math.min(best, minimax(board, depth+1, !isMax));
                board[i].setMarker(Token.EMPTY);
            }
        }
        return best;
    }
}

public int findBestMove(Cell[] board) {
    int bestValue = -1000;
    int bestMove = -1;
    for (int i=0; i<board.length; i++) {
        if (board[i].getMarker() == Token.EMPTY) {
            board[i].setMarker(botPlayer);
            int moveValue = minimax(board, 0, false);
            board[i].setMarker(Token.EMPTY);
            if (moveValue > bestValue) {
                bestMove = i;
                bestValue = moveValue;
            }
        }
    }
    return bestMove;
}
}

---

当您的递归完成一个分支时，您正在将一个已经计算过的移动设置回

Token.EMPTY

，以便在另一个移动中执行分支。我不认为这是一个逻辑错误

best = Math.max(best, minimax(board, depth+1, !isMax));
board[i].setMarker(Token.EMPTY)

---

相反，调用不执行检查的

resetMarker

函数。

这不是预期的异常吗？当您的递归完成一个分支时，您正在将一个已经计算过的移动设置回

Token.EMPTY

，以便在另一个移动中执行分支。我不认为这是一个逻辑错误<代码>最佳=数学最大值（最佳，最小最大值（电路板，深度+1，！isMax））；线路板[i].setMarker（Token.EMPTY）

public class Cell {
    Token marker;

public Cell() {
    marker = Token.EMPTY;
}

public Token getMarker() {
    return marker;
}

public void setMarker(Token token) {
    if (marker != Token.EMPTY) {
        throw new CellIsNotAvailableException("This cell is occupied.");
    }
    else {
        marker = token;
    }
}

public void resetMarker() {
    marker = Token.EMPTY;
}
}

best = Math.max(best, minimax(board, depth+1, !isMax));
board[i].setMarker(Token.EMPTY)