Game

/**
 * 极大层搜索方法
 * @param chessBoard 当前棋盘
 * @param depth 博弈树搜索深度
 * @param alpha 极大层更新值
 * @param beta 极小层更新值
 * @param player 玩家标识
 * @return score 和 position的对象
 */
private static MiniMaxResult max(int[][] chessBoard,int depth,int alpha,int beta,int player) {
    Rule rule = new Rule();
    //深度为0 返回当前局面评分
    if (depth == 0)
        return new MiniMaxResult(rule.evaluate(chessBoard,player),null);

    //获取当前玩家所有可行走步
    List<Position> legalMovesMe = rule.getAllLegalMoves(chessBoard,player);
    //取对手棋子
    int enemyPlayer = player == Constant.BLACK.getValue() ? Constant.WHITE.getValue() : Constant.BLACK.getValue();

    //终局：双方均没有步可走 返回当前局面评分
    if (legalMovesMe.size() == 0){
        if (rule.getAllLegalMoves(chessBoard,enemyPlayer).size() == 0){
            return new  MiniMaxResult(rule.evaluate(chessBoard,player),null);
        }
        //单方无处可走 调用min递归
        return min(chessBoard,depth,alpha,beta,enemyPlayer);
    }
    //拷贝当前棋盘到新棋盘
    int[][] temp = new int[chessBoard.length][chessBoard[0].length];
    for (int i = 0; i < chessBoard.length; i++) {
        for (int j = 0; j < chessBoard[0].length; j++) {
            temp[i][j] = chessBoard[i][j];
        }
    }
    int best = Integer.MIN_VALUE; //当前max节点维护的一个最佳值，调用min方法的alpha = alpha 和best的较大的那个
    Position position = null;

    //正常情况有步可走，遍历每个合法走步
        //if alpha > beta 剪枝 break
        //否则走步递归
    for (int i = 0; i < legalMovesMe.size(); i++) {
        alpha = Math.max(best,alpha);
        if (alpha >= beta) {
            break; //剪枝
        }
        //开始走步
        rule.move(temp,legalMovesMe.get(i),player);
        int value = min(chessBoard,depth - 1,Math.max(best,alpha),beta,enemyPlayer).getScore();
        if (value > best) {
            best = value;
            position = legalMovesMe.get(i); //取分高的走步作为下一步走步
        }
        //拷贝当前走步所得棋盘
        for (int p = 0; p < chessBoard.length; p++) {
            for (int j = 0; j < chessBoard[0].length; j++) {
                chessBoard[p][j] = temp[p][j];
            }
        }
    }
    return new MiniMaxResult(best,position);
}

private static MiniMaxResult min(int[][] chessBoard, int depth, int alpha, int beta, int player) {
    Rule rule = new Rule();
    if (depth == 0) {
        return new MiniMaxResult(rule.evaluate(chessBoard,player),null);
    }
    List<Position> legalMovesMe = rule.getAllLegalMoves(chessBoard,player);
    //取对手棋子
    int enemyPlayer = player == Constant.BLACK.getValue() ? Constant.WHITE.getValue() : Constant.BLACK.getValue();
    if (legalMovesMe.size() == 0) {
        if (rule.getAllLegalMoves(chessBoard,enemyPlayer).size() == 0) {
            return new MiniMaxResult(rule.evaluate(chessBoard,player),null);
        }
        return max(chessBoard,depth,alpha,beta,enemyPlayer);
    }
    //拷贝当前棋盘到新棋盘
    int[][] temp = new int[chessBoard.length][chessBoard[0].length];
    for (int i = 0; i < chessBoard.length; i++) {
        for (int j = 0; j < chessBoard[0].length; j++) {
            temp[i][j] = chessBoard[i][j];
        }
    }
    int best = Integer.MAX_VALUE;
    Position position = null;

    for (int i = 0; i < legalMovesMe.size(); i++) {
        beta = Math.min(best,beta); //beta取当前值和beta中较小的一个
        if (alpha >= beta) {
            break;
        }
        rule.move(temp,legalMovesMe.get(i),player);
        int value = max(chessBoard,depth-1,alpha,Math.min(best,beta),enemyPlayer).getScore();
        if (value < best) {
            best = value;
            position = legalMovesMe.get(i);
        }
        //拷贝当前走步所得棋盘
        for (int p = 0; p < chessBoard.length; p++) {
            for (int j = 0; j < chessBoard[0].length; j++) {
                chessBoard[p][j] = temp[p][j];
            }
        }
    }
    return new MiniMaxResult(best,position);
}

/**
 * 黑白棋评估函数 考虑评估因素：
 * 棋子个数
 * 边角 赋边界位置权重 5 2 1
 * 行动力 棋子合法下一步合法走步数量
 * 稳定度
 * @param chessBoard
 * @param player
 * @return
 */
public int evaluate(int[][] chessBoard,int player) {
    int playerScore = 0;
    int enemyScore = 0;
    //取对手棋子
    int enemyPlayer = player == Constant.BLACK.getValue() ? Constant.WHITE.getValue() : Constant.BLACK.getValue();
    /**
     * 棋子个数
     */
    for (int i = 0; i < 8; i++) {
        for (int j = 0; j < 8; j++) {
            if (chessBoard[i][j] == player) {
                playerScore += 1;
            } else if (chessBoard[i][j] == enemyPlayer) {
                enemyScore += 1;
            }
        }
    }
    /**
     * 边角
     */
    for (int i = 0; i < 8; i++) {
        for (int j = 0; j < 8; j++) {
            if ((i == 0 || i == 7) && (j == 0 || j == 7)) {
                if (chessBoard[i][j] == player) {
                    playerScore += 5;
                } else if (chessBoard[i][j] == enemyPlayer) {
                    enemyScore += 5;
                }
            } else if (i == 0 || i == 7 || j == 0 || j == 7) {
                if (chessBoard[i][j] == player) {
                    playerScore += 2;
                } else if (chessBoard[i][j] == enemyPlayer) {
                    enemyScore += 2;
                }
            } else {
                if (chessBoard[i][j] == player) {
                    playerScore += 1;
                } else if (chessBoard[i][j] == enemyPlayer) {
                    enemyScore += 1;
                }
            }
        }
    }
    /**
     * 稳定度
     */
    for (int i = 0; i < 8; i++) {
        for (int j = 0; j < 8; j++) {
            int weight[] = new int[] { 2, 4, 6, 10, 15 };
            if (chessBoard[i][j] == player) {
                playerScore += weight[getStabilizationDegree(chessBoard, new Position(i, j))];
            } else if (chessBoard[i][j] == enemyPlayer) {
                enemyScore += weight[getStabilizationDegree(chessBoard, new Position(i, j))];
            }
        }
    }
    /**
     * 行动力
     */
    playerScore += getAllLegalMoves(chessBoard, player).size();
    enemyScore += getAllLegalMoves(chessBoard, enemyPlayer).size();

    return playerScore - enemyScore;

}

/**
 * 计算某位置处 player棋子稳定度
 * 若player 某一方向直到不为空（包括边界）的两个位置 左-右 上-下 左上-右下 右上-左下 的某一个位置，至少有一个出界 || 两个均为敌方棋子 稳定度加一
 *
 * @param board 当前棋盘
 * @param position 当前棋子坐标
 * @return 棋子稳定度
 */
private static int getStabilizationDegree(int[][] board, Position position) {
    int player = board[position.getY()][position.getY()];
    //敌方棋子
    int enemy = player == Constant.BLACK.getValue() ? Constant.WHITE.getValue() : Constant.BLACK.getValue();
    int drow[][], dcol[][];
    int row[] = new int[2], col[] = new int[2];
    int degree = 0;

    drow = new int[][] { { 0, 0 }, { -1, 1 }, { -1, 1 }, { 1, -1 } };
    dcol = new int[][] { { -1, 1 }, { 0, 0 }, { -1, 1 }, { -1, 1 } };

    for (int k = 0; k < 4; k++) {
        row[0] = row[1] = position.getX();
        col[0] = col[1] = position.getY();
        for (int i = 0; i < 2; i++) {
            while (Rule.isLegal(row[i] + drow[k][i], col[i] + dcol[k][i])
                    && board[row[i] + drow[k][i]][col[i] + dcol[k][i]] == player) {
                row[i] += drow[k][i];
                col[i] += dcol[k][i];
            }
        }
        if (!Rule.isLegal(row[0] + drow[k][0], col[0] + dcol[k][0])
                || !Rule.isLegal(row[1] + drow[k][1], col[1] + dcol[k][1])) {
            degree += 1;
        } else if (board[row[0] + drow[k][0]][col[0] + dcol[k][0]] == enemy
                && board[row[1] + drow[k][1]][col[1] + dcol[k][1]] == enemy) {
            degree += 1;
        }
    }
    return degree;
}