java - 为什么我的 2D Array Maze 不打印生成的内容？

Question

我的目标是生成一个由 Cell 对象的二维数组组成的迷宫。下面是单元格和迷宫的代码。使用调试器我可以看到 boolean 值正在改变，并且生成按预期进行，但是当它得到打印时，没有路径。所有的墙都还在原地，我似乎无法弄清楚断开连接的地方，如果有的话？

这是 Cell 类:

public class Cell {
    //coordinates
    private int x;
    private int y;
    //cell status
    private boolean visited;
    //cell walls status
    private boolean northWall;
    private boolean southWall;
    private boolean eastWall;
    private boolean westWall;

    public Cell(int x, int y) {
        this.x = x;
        this.y = y;
        visited =  false;
        northWall= true;
        southWall= true;
        eastWall = true;
        westWall = true;
    }

    public int getX() {
        return x;
    }

    public int getY() {
        return y;
    }

    public boolean isVisited() {
        return visited;
    }

    public void setVisited(boolean visited) {
        this.visited = visited;
    }

    public boolean isNorthWall() {
        return northWall;
    }

    public void setNorthWall(boolean northWall) {
        this.northWall = northWall;
    }

    public boolean isSouthWall() {
        return southWall;
    }

    public void setSouthWall(boolean southWall) {
        this.southWall = southWall;
    }

    public boolean isEastWall() {
        return eastWall;
    }

    public void setEastWall(boolean eastWall) {
        this.eastWall = eastWall;
    }

    public boolean isWestWall() {
        return westWall;
    }

    public void setWestWall(boolean westWall) {
        this.westWall = westWall;
    }

这是迷宫类:

public class Maze {
private Cell[][] maze;
private int height;
private int width;

//generate the full 2d array of cell objects. all the 'visited's are false and all the walls are true(that's done in the cells constructor).

public Maze(int height, int width) {
    //initialize the number of rows and columns in the maze with the numbers entered
    this.height = height;
    this.width = width;

    //initialize the 2d maze with the number of spaces allocated by the height and width entered
    maze = new Cell[height][width];
    //fill the maze with cells
    generateMaze();
    //dig a an open path through the maze
    generatePath();
    //print the maze in the console
    printMaze();
}

/**
 * The generateMaze method fills the maze with unvisited, walled cells.
 */
public void generateMaze() {
    for(int i = 0; i < height; i++) {
        for(int j = 0; j < width; j++) {
            maze[i][j] = new Cell(i, j);
        }
    }
}

/**
 * The generatePath method digs or generates a random open path through the maze of cells.
 */
private void generatePath() {
    //Find the starting point to start digging.
    Random rand = new Random();
    int row = rand.nextInt(height);
    int col = rand.nextInt(width);

    //starting cell
    maze[row][col].setVisited(true);

    //start digging the path
    dig(row, col);

}

//Depth-First Searching Algorithm that digs in increments of 1
public void dig(int row, int column){
    //generate four random directions
    Integer[] randDirs = generateRandomDirections();
    //examine each direction
    for(int i = 0; i < randDirs.length;i++) {
        switch (randDirs[i]) {
            case 1: //Up
                //whether one cells up is in the maze or not
                if (row - 1 <= 0) {
                    continue;
                }
                //whether one cells up has been visited
                if (!maze[row - 1][column].isVisited()) {
                    maze[row - 1][column].setVisited(true);
                    maze[row][column].setNorthWall(false);
                    maze[row - 1][column].setSouthWall(false);
                    dig(row - 1, column);
                }
                break;
            case 2: //Right
                //whether one cells right is in the maze or not
                if (column + 1 >= width - 1) { //alternative: (column + 2 >= width - 1) ??
                    continue;
                }
                //whether one cells right has been visited
                if (!maze[row][column + 1].isVisited()) {
                    maze[row][column + 1].setVisited(true);
                    maze[row][column].setEastWall(false);
                    maze[row][column + 1].setWestWall(false);
                    dig(row, column + 1);
                }
                break;
            case 3: //Down
                //whether one cells down is in the maze or not
                if (row + 1 >= height - 1) {//alternative: (row + 2 >= height - 1) ??
                    continue;
                }
                //whether one cells down has been visited
                if (!maze[row + 1][column].isVisited()) {
                    maze[row + 1][column].setVisited(true);
                    maze[row][column].setSouthWall(false);
                    maze[row + 1][column].setNorthWall(false);
                    dig(row + 1, column);
                }
                break;
            case 4: //Left
                //whether one cells left is in the maze or not
                if (column - 1 <= 0) {
                    continue;
                }
                //whether one cells left has been visited
                if (!maze[row][column - 1].isVisited()) {
                    maze[row][column - 1].setVisited(true);
                    maze[row][column].setWestWall(false);
                    maze[row][column - 1].setEastWall(false);
                    dig(row, column - 1);
                }
                break;
        }
    }
}

/**
 * The generateRandomDirections() class generates an array with random directions 1-4
 * @return Array containing 4 directions in random order
 */
public Integer[] generateRandomDirections() {
    ArrayList<Integer> randoms = new ArrayList<>();
    for(int i = 0; i < 4; i++) {
        randoms.add(i + 1);
    }
    Collections.shuffle(randoms);
    return randoms.toArray(new Integer[4]);
}

/**
 * The printMaze() method prints out the maze of cells generated by the GenerateMaze class, to the console.
 */
public void printMaze() {
    for (int i = 0; i < height; i++) {
        System.out.println();
        for (int j = 0; j < width; j++) {
            Cell current = new Cell(i, j);
            StringBuilder string = new StringBuilder();
            if(current.isWestWall()){
                string.append("|");
            }
            if(current.isSouthWall()) {
                string.append("_");
            }
            else{
                string.append(" ");
            }
            System.out.print(string);
        }
    }
}

我总是得到以下输出:

|_|_|_|_|_|_|_
|_|_|_|_|_|_|_
|_|_|_|_|_|_|_
|_|_|_|_|_|_|_
|_|_|_|_|_|_|_
|_|_|_|_|_|_|_
|_|_|_|_|_|_|_
Process finished with exit code 0

任何关于我的问题可能是什么的想法都将不胜感激。谢谢。

Answer 1

你不是在打印你的迷宫。

在 printMaze() 方法中，您正确地遍历了迷宫，但不是打印出迷宫单元格，而是在每次迭代时创建一个新的(空白)单元格。

public void printMaze() {
    for (int i = 0; i < height; i++) {
        /* ... */
        for (int j = 0; j < width; j++) {
            Cell current = new Cell(i, j); // <- HERE
            /* ... */
        }
        /* ... */
    }
    /* ... */
}

那一行应该是:

Cell current = maze[i][j];