用javafx写一个迷宫游戏要求有自动寻路功能并且可以调节迷宫难度

好的，下面是一个基于JavaFX的迷宫游戏的实现，包括自动寻路功能和难度调节。代码如下：

MazeGame.java：

import javafx.application.Application;
import javafx.geometry.Pos;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.control.Label;
import javafx.scene.layout.BorderPane;
import javafx.scene.layout.GridPane;
import javafx.scene.layout.StackPane;
import javafx.scene.paint.Color;
import javafx.scene.shape.Rectangle;
import javafx.stage.Stage;

import java.util.*;

public class MazeGame extends Application {

    private static final int WIDTH = 500;
    private static final int HEIGHT = 500;

    private static final int EASY_SIZE = 10;
    private static final int MEDIUM_SIZE = 20;
    private static final int HARD_SIZE = 30;

    private static final int CELL_SIZE = 20;

    private static final Color WALL_COLOR = Color.BLACK;
    private static final Color PATH_COLOR = Color.WHITE;
    private static final Color START_COLOR = Color.GREEN;
    private static final Color END_COLOR = Color.RED;
    private static final Color VISITED_COLOR = Color.GRAY;

    private static final int[][] DIRECTIONS = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};

    private int[][] maze;
    private boolean[][] visited;

    private int startX, startY;
    private int endX, endY;

    private StackPane[][] cells;

    private Button easyButton, mediumButton, hardButton, solveButton;

    private Label messageLabel;

    private boolean solving;

    @Override
    public void start(Stage primaryStage) throws Exception {
        BorderPane root = new BorderPane();

        GridPane mazePane = new GridPane();
        mazePane.setAlignment(Pos.CENTER);
        root.setCenter(mazePane);

        easyButton = new Button("Easy");
        mediumButton = new Button("Medium");
        hardButton = new Button("Hard");
        solveButton = new Button("Solve");

        easyButton.setOnAction(event -> generateMaze(EASY_SIZE));
        mediumButton.setOnAction(event -> generateMaze(MEDIUM_SIZE));
        hardButton.setOnAction(event -> generateMaze(HARD_SIZE));
        solveButton.setOnAction(event -> solveMaze());

        messageLabel = new Label("");
        messageLabel.setAlignment(Pos.CENTER);
        messageLabel.setPrefWidth(WIDTH);

        BorderPane bottomPane = new BorderPane();
        bottomPane.setLeft(easyButton);
        bottomPane.setCenter(mediumButton);
        bottomPane.setRight(hardButton);
        bottomPane.setBottom(solveButton);

        root.setTop(messageLabel);
        root.setBottom(bottomPane);

        primaryStage.setTitle("Maze Game");
        primaryStage.setScene(new Scene(root, WIDTH, HEIGHT));
        primaryStage.show();

        generateMaze(EASY_SIZE);
    }

    private void generateMaze(int size) {
        maze = new int[size][size];
        visited = new boolean[size][size];

        cells = new StackPane[size][size];

        startX = (int) (Math.random() * size);
        startY = (int) (Math.random() * size);

        endX = (int) (Math.random() * size);
        endY = (int) (Math.random() * size);

        while (endX == startX && endY == startY) {
            endX = (int) (Math.random() * size);
            endY = (int) (Math.random() * size);
        }

        for (int i = 0; i < size; i++) {
            for (int j = 0; j < size; j++) {
                if (i == startX && j == startY) {
                    maze[i][j] = 0;
                } else if (i == endX && j == endY) {
                    maze[i][j] = 0;
                } else {
                    maze[i][j] = 1;
                }
                visited[i][j] = false;

                StackPane cell = new StackPane();
                Rectangle rect = new Rectangle(CELL_SIZE, CELL_SIZE);
                rect.setFill(WALL_COLOR);
                cell.getChildren().add(rect);

                cells[i][j] = cell;

                GridPane.setConstraints(cell, j, i);
                mazePane.getChildren().add(cell);
            }
        }

        generateMazeRecursive(startX, startY);

        solving = false;
        messageLabel.setText("");
    }

    private void generateMazeRecursive(int x, int y) {
        visited[x][y] = true;

        List<int[]> neighbors = new ArrayList<>();
        for (int[] dir : DIRECTIONS) {
            int nx = x + dir[0];
            int ny = y + dir[1];

            if (nx >= 0 && nx < maze.length && ny >= 0 && ny < maze.length && !visited[nx][ny]) {
                neighbors.add(new int[]{nx, ny});
            }
        }

        while (!neighbors.isEmpty()) {
            int idx = (int) (Math.random() * neighbors.size());
            int[] neighbor = neighbors.get(idx);

            int nx = neighbor[0];
            int ny = neighbor[1];

            if (maze[nx][ny] == 1) {
                maze[nx][ny] = 0;

                StackPane cell = cells[nx][ny];
                cell.getChildren().clear();
                cell.getChildren().add(new Rectangle(CELL_SIZE, CELL_SIZE, PATH_COLOR));

                generateMazeRecursive(nx, ny);
            }

            neighbors.remove(idx);
        }
    }

    private void solveMaze() {
        if (solving) {
            return;
        }

        solving = true;

        messageLabel.setText("Solving...");

        Queue<int[]> queue = new LinkedList<>();
        queue.offer(new int[]{startX, startY});

        while (!queue.isEmpty()) {
            int[] cur = queue.poll();
            int x = cur[0];
            int y = cur[1];

            if (x == endX && y == endY) {
                break;
            }

            for (int[] dir : DIRECTIONS) {
                int nx = x + dir[0];
                int ny = y + dir[1];

                if (nx >= 0 && nx < maze.length && ny >= 0 && ny < maze.length && maze[nx][ny] == 0 && !visited[nx][ny]) {
                    queue.offer(new int[]{nx, ny});
                    visited[nx][ny] = true;

                    StackPane cell = cells[nx][ny];
                    cell.getChildren().clear();
                    cell.getChildren().add(new Rectangle(CELL_SIZE, CELL_SIZE, VISITED_COLOR));
                }
            }
        }

        if (visited[endX][endY]) {
            messageLabel.setText("Path found!");
            drawPath();
        } else {
            messageLabel.setText("No path found.");
        }

        solving = false;
    }

    private void drawPath() {
        int x = endX;
        int y = endY;

        Stack<int[]> stack = new Stack<>();
        while (x != startX || y != startY) {
            stack.push(new int[]{x, y});

            for (int[] dir : DIRECTIONS) {
                int nx = x + dir[0];
                int ny = y + dir[1];

                if (nx >= 0 && nx < maze.length && ny >= 0 && ny < maze.length && visited[nx][ny] && maze[nx][ny] == 0) {
                    x = nx;
                    y = ny;
                    break;
                }
            }
        }
        stack.push(new int[]{startX, startY});

        while (!stack.isEmpty()) {
            int[] pos = stack.pop();
            int px = pos[0];
            int py = pos[1];

            StackPane cell = cells[px][py];
            cell.getChildren().clear();
            cell.getChildren().add(new Rectangle(CELL_SIZE, CELL_SIZE, PATH_COLOR));
        }
    }

    public static void main(String[] args) {
        launch(args);
    }
}

这个迷宫游戏包括四个按钮：Easy、Medium、Hard 和 Solve。Easy、Medium、Hard 分别对应不同的迷宫大小，点击后会自动生成迷宫。Solve 按钮用于寻找从起点到终点的路径。当点击 Solve 按钮时，程序会使用广度优先搜索算法遍历迷宫，找到从起点到终点的最短路径。

在实现中，迷宫是用一个二维数组来表示的，其中 0 表示路径，1 表示墙。生成迷宫时，程序使用递归深度优先搜索算法，从起点开始逐步拓展迷宫，直到达到终点。在搜索过程中，程序会将路径用白色矩形表示，墙用黑色矩形表示。在搜索完成后，程序会使用广度优先搜索算法遍历迷宫，找到从起点到终点的最短路径，并用灰色矩形表示已经访问过的节点，用白色矩形表示路径。