国际象棋AI MiniMax算法不工作

Question

我已经在我的国际象棋AI中实现了极大极小算法，我知道它不能正常工作，因为它只是一次又一次地来回移动一个棋子。

getPieces（true）返回当前棋盘状态下的所有白色棋子

getPieces（false）返回当前板状态下的所有黑色块

ChessPiece.getAllPoentialMoves（）非常不言自明，获取特定块的所有可能移动

PieceMovements.move（）移动一块（p）到位置（m-

PieceMovements.undo（）撤消之前的移动

Search chDepth是一个变量，当第一次调用MiniMax时，它首先作为深度值传递，换句话说，它是您想要向下搜索多远。的原因...

if(depth == searchDepth) {
    piece = p;
    move = m;
}

...是记录这首曲子，然后移动。我把这个值记录在搜索树的顶层，块和移动代表算法认为最高效的实际块和移动。

当调用miniMax时，它看起来是这样的：miniMax（searchDepth，false）。错误，因为AI，黑色，是最小值。

这是我的方法

public int miniMax(int depth, boolean maxi) {

    if(maxi) {
        if(depth == 0) return evaluateBoard();
        int max = -9999; //negative infinity
        for(ChessPiece p : getPieces(maxi)) for(Vector2 m : p.getAllPotentialMoves()) {
                PieceMovements.move(board, p, (int)m.x, (int)m.y);
                max = Math.max(max, miniMax(depth-1, !maxi));
                PieceMovements.undo();
                if(depth == searchDepth) {
                    piece = p;
                    move = m;
                }
            }
        return max;
    } else {
        if(depth == 0) return -evaluateBoard();
        int min = 9999; //positive infinity
        for(ChessPiece p : getPieces(maxi)) for(Vector2 m : p.getAllPotentialMoves()) {
                PieceMovements.move(board, p, (int)m.x, (int)m.y);
                min = Math.min(min, miniMax(depth-1, !maxi));
                PieceMovements.undo();
                if(depth == searchDepth) {
                    piece = p;
                    move = m;
                }
            }
        return min;
    }
}

还有我的评估函数，它目前只取每件作品的相对作品值，并将它们相加：

public int evaluateBoard() {
    int total = 0;
    for(ChessPiece[] row : board)
        for(ChessPiece piece : row)
            if(piece != null)
                switch(piece.getPiece()) {
                    case WPAWN:
                    case BPAWN:
                        total += RelativePieceValues.PAWN;
                        //a pawn about to be promoted takes on more value
                        if(piece.getPosition().y == 1 || piece.getPosition().y == 6)
                            total += 50; //50 + 10 = 60
                        break;
                    case WKNIGHT:
                    case BKNIGHT:
                        total += RelativePieceValues.KNIGHT;
                        break;
                    case WBISHOP:
                    case BBISHOP:
                        total += RelativePieceValues.BISHOP;
                        break;
                    case WROOK:
                    case BROOK:
                        total += RelativePieceValues.ROOK;
                        break;
                    case WQUEEN:
                    case BQUEEN:
                        total += RelativePieceValues.QUEEN;
                        break;
                    case WKING:
                    case BKING:
                        total += RelativePieceValues.KING;
                        break;
                }

    return total;
}

和相对值类：

public class RelativePieceValues{

//piece value constants
public static final int PAWN = 10;
public static final int KNIGHT = 30;
public static final int BISHOP = 30;
public static final int ROOK = 50;
public static final int QUEEN = 90;
public static final int KING = 900;
}

如果您有任何问题，请提问。谢谢你的任何回复，我已经被困在这一段时间了。我想知道我的迷你最大算法或我的评估函数是否真的有问题，或者我的程序中可能还有你看不到的其他问题。谢谢。

Answer 1

正如答案中指出的，您没有使用minimax函数的结果。下面是我用Python开发的工作版本，希望您能将其翻译成java:）

这一个是使用alpha-beta修剪来提高性能。

具有极小值函数的初始调用：

best_move, evaluation = minimax(board, 5, -math.inf, math.inf, True)

最小值函数本身。board.is_human_turn在棋盘类中用于确定玩家是谁。然后我们得到那个球员（位置的孩子）所有可能的移动。

然后它检查我们是否达到了最大深度，或者它是否在这个位置上结束了游戏（平局或检查伴侣）。

对于每个玩家（分别最大化和最小化），它会遍历所有的子玩家。它制作了一个板副本（不与原始板更改）并在板上移动（一个孩子）。然后，它计算所有节点中的计算值，并随计算值返回最佳移动。

def minimax(board, depth, alpha, beta, maximizing_player):

    board.is_human_turn = not maximizing_player
    children = board.get_all_possible_moves()

    if depth == 0 or board.is_draw or board.is_check_mate:
        return None, evaluate(board)

    best_move = random.choice(children)

    if maximizing_player:
        max_eval = -math.inf
        for child in children:
            board_copy = copy.deepcopy(board)
            board_copy.move(child)
            current_eval = minimax(board_copy, depth - 1, alpha, beta, False)[1]
            if current_eval > max_eval:
                max_eval = current_eval
                best_move = child
            alpha = max(alpha, current_eval)
            if beta <= alpha:
                break
        return best_move, max_eval

    else:
        min_eval = math.inf
        for child in children:
            board_copy = copy.deepcopy(board)
            board_copy.move(child)
            current_eval = minimax(board_copy, depth - 1, alpha, beta, True)[1]
            if current_eval < min_eval:
                min_eval = current_eval
                best_move = child
            beta = min(beta, current_eval)
            if beta <= alpha:
                break
        return best_move, min_eval

我的评估函数目前非常简单，只考虑棋子值以及它们在棋盘上的位置。例如，一个骑士本来值320，然后你根据它的位置进行加减。有关更多信息，请参阅此链接：https://www.chessprogramming.org/Simplified_Evaluation_Function.

你也可以实现一个开场白，这样你就可以在每场比赛中有一个好的开始，而不必花时间计算位置。

希望这有帮助！