javafx写一个拼图游戏,要求能实时显示所走步数和所用时间

好的，我可以帮你实现一个简单的拼图游戏，使用JavaFX作为UI框架。以下是实现步骤：

1. 创建一个JavaFX项目，并编写UI界面，包括一个拼图区域和一个计时器和步数统计器区域。

2. 创建一个`Puzzle`类，用于保存拼图状态和实现拼图移动的逻辑。

3. 在UI界面中，将拼图区域划分为若干个小格子，每个小格子对应`Puzzle`中的一个拼图块。

4. 在UI界面中，为每个小格子绑定一个`Puzzle`中拼图块的位置。

5. 当用户点击某个小格子时，使用`Puzzle`类实现拼图块的移动，并更新计时器和步数统计器。

下面是一些代码示例：

public class Puzzle {
    private final int[][] board;
    private final int numRows;
    private final int numCols;
    private int emptyRow;
    private int emptyCol;
    private int numMoves;

    public Puzzle(int[][] board) {
        this.board = board;
        this.numRows = board.length;
        this.numCols = board[0].length;
        findEmpty();
    }

    private void findEmpty() {
        for (int r = 0; r < numRows; r++) {
            for (int c = 0; c < numCols; c++) {
                if (board[r][c] == 0) {
                    emptyRow = r;
                    emptyCol = c;
                    return;
                }
            }
        }
        throw new IllegalStateException("No empty cell found");
    }

    public boolean isSolved() {
        int expected = 1;
        for (int r = 0; r < numRows; r++) {
            for (int c = 0; c < numCols; c++) {
                if (board[r][c] != expected % (numRows * numCols)) {
                    return false;
                }
                expected++;
            }
        }
        return true;
    }

    public boolean move(int r, int c) {
        if (board[r][c] != 0) {
            return false;
        }
        if (r == emptyRow && c == emptyCol) {
            return false;
        }
        if (r == emptyRow) {
            int start = Math.min(c, emptyCol);
            int end = Math.max(c, emptyCol);
            for (int i = start; i <= end; i++) {
                swap(r, i);
            }
        } else if (c == emptyCol) {
            int start = Math.min(r, emptyRow);
            int end = Math.max(r, emptyRow);
            for (int i = start; i <= end; i++) {
                swap(i, c);
            }
        } else {
            return false;
        }
        emptyRow = r;
        emptyCol = c;
        numMoves++;
        return true;
    }

    private void swap(int r, int c) {
        int temp = board[r][c];
        board[r][c] = board[emptyRow][emptyCol];
        board[emptyRow][emptyCol] = temp;
        emptyRow = r;
        emptyCol = c;
    }

    public int getNumMoves() {
        return numMoves;
    }

    public int getElapsedTime() {
        // 返回经过的时间，单位秒
        return (int) (System.currentTimeMillis() - startTime) / 1000;
    }
}

public class PuzzleApp extends Application {
    private static final int NUM_ROWS = 3;
    private static final int NUM_COLS = 3;
    private static final int TILE_SIZE = 100;

    private Puzzle puzzle;
    private GridPane puzzlePane;
    private Label movesLabel;
    private Label timeLabel;
    private Timer timer;
    private int elapsedTime;

    @Override
    public void start(Stage primaryStage) {
        puzzle = new Puzzle(generateBoard());
        puzzlePane = new GridPane();
        movesLabel = new Label("Moves: 0");
        timeLabel = new Label("Time: 0s");
        timer = new Timer();

        // 创建拼图区域
        for (int r = 0; r < NUM_ROWS; r++) {
            for (int c = 0; c < NUM_COLS; c++) {
                int value = puzzle.get(r, c);
                Pane tile = createTile(value);
                puzzlePane.add(tile, c, r);
            }
        }

        // 创建计时器和步数统计器
        VBox statsPane = new VBox(movesLabel, timeLabel);
        statsPane.setAlignment(Pos.CENTER);
        statsPane.setSpacing(10);

        // 将拼图区域和计时器和步数统计器组合到一个BorderPane中
        BorderPane root = new BorderPane();
        root.setCenter(puzzlePane);
        root.setBottom(statsPane);

        // 开始计时
        timer.scheduleAtFixedRate(new TimerTask() {
            @Override
            public void run() {
                elapsedTime = puzzle.getElapsedTime();
                Platform.runLater(() -> updateTimeLabel());
            }
        }, 1000, 1000);

        // 处理拼图块点击事件
        puzzlePane.setOnMouseClicked(event -> {
            int r = GridPane.getRowIndex(event.getTarget());
            int c = GridPane.getColumnIndex(event.getTarget());
            if (puzzle.move(r, c)) {
                updatePuzzle();
                updateMovesLabel();
                if (puzzle.isSolved()) {
                    showSuccessDialog();
                    timer.cancel();
                }
            }
        });

        Scene scene = new Scene(root);
        primaryStage.setScene(scene);
        primaryStage.setTitle("Puzzle Game");
        primaryStage.show();
    }

    private Pane createTile(int value) {
        Pane tile = new Pane();
        tile.setPrefSize(TILE_SIZE, TILE_SIZE);
        tile.getStyleClass().add("tile");

        Text text = new Text(Integer.toString(value));
        text.setFont(Font.font(36));
        text.setFill(Color.WHITE);
        tile.getChildren().add(text);

        return tile;
    }

    private void updatePuzzle() {
        for (int r = 0; r < NUM_ROWS; r++) {
            for (int c = 0; c < NUM_COLS; c++) {
                int value = puzzle.get(r, c);
                Pane tile = (Pane) puzzlePane.getChildren().get(r * NUM_COLS + c);
                Text text = (Text) tile.getChildren().get(0);
                text.setText(Integer.toString(value));
            }
        }
    }

    private void updateMovesLabel() {
        int numMoves = puzzle.getNumMoves();
        movesLabel.setText("Moves: " + numMoves);
    }

    private void updateTimeLabel() {
        timeLabel.setText("Time: " + elapsedTime + "s");
    }

    private void showSuccessDialog() {
        Alert alert = new Alert(Alert.AlertType.INFORMATION);
        alert.setTitle("Congratulations!");
        alert.setHeaderText(null);
        alert.setContentText("You solved the puzzle in " + elapsedTime + " seconds with " + puzzle.getNumMoves() + " moves.");
        alert.showAndWait();
    }

    private int[][] generateBoard() {
        List<Integer> values = new ArrayList<>();
        for (int i = 1; i < NUM_ROWS * NUM_COLS; i++) {
            values.add(i);
        }
        Collections.shuffle(values);
        int[][] board = new int[NUM_ROWS][NUM_COLS];
        for (int r = 0; r < NUM_ROWS; r++) {
            for (int c = 0; c < NUM_COLS; c++) {
                board[r][c] = values.get(r * NUM_COLS + c);
            }
        }
        board[NUM_ROWS - 1][NUM_COLS - 1] = 0;
        return board;
    }

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

以上是一个简单的基于JavaFX的拼图游戏实现，其中包含了实时显示所走步数和所用时间的功能。