我已经在我的国际象棋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;
}

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