Java：带滑动的基于网格的路径查找

Question

I have made a simple puzzle game where you slide a ball either vertically or horizontally on a grid. The level format is just an array with 1 meaning a tile you can be onto and 0 being a wall. It's not possible to stop until the ball meets a wall.

Example level:

map[][] = {
    {0,0,0,0,0,0,0,0,0,0,0,0,0},
    {0,1,1,1,0,0,2,0,1,1,1,1,0},
    {0,0,1,1,1,1,1,1,1,1,0,1,0},
    {0,1,1,1,1,0,1,1,1,1,1,1,0},
    {0,1,0,1,1,1,1,1,1,1,1,1,0},
    {0,1,0,1,1,1,1,1,0,1,1,1,0},
    {0,1,1,0,1,1,1,1,1,1,1,1,0},
    {0,1,1,1,0,1,1,0,1,1,1,1,0},
    {0,1,1,1,1,0,1,1,1,1,1,1,0},
    {0,1,1,1,1,1,0,1,1,0,1,1,0},
    {0,1,1,1,1,1,3,1,1,1,1,1,0},
    {0,0,0,0,0,0,0,0,0,0,0,0,0}
}

(I know it's a bit troublesome to have Y-axis first)

The problem is how on earth can one make an algorithm that solves all possible routes from the starting point (3) to the goal (2). This made me look up some common algorithms online but they only solved:

• a route on a grid with free movement
• the most efficient route

I have written this:

//keep track of tiles the player has already been to
List<Integer> beenToX = new ArrayList<Integer>();
List<Integer> beenToY = new ArrayList<Integer>();
beenToX.add(0, 6); //starting x-coordinate
beenToY.add(0, 10); //starting y-coordinate
Boolean solving = true;
while (solving) {
    for (int i = 0; i < 4; i++) { //num of directions N=0, E=1, S=2, W=3
        for (int j = 1; j < 11; j++) {
            if (i == 0) {
                if (map[beenToY.get(0)+j][beenToX.get(0)] == 0) {
                    beenToX.add(0, currentX);
                    beenToY.add(0, beenToY.get(0)+j);
                    break;
                }
                if (map[beenToY.get(0)+j][beenToX.get(0)] == 2) {
                    beenToX.add(0, currentX);
                    beenToY.add(0, beenToY.get(0)+j);
                    solving = false;
                    break;
                }
            }
            if (i == 1) {
                if (map[beenToY.get(0)][beenToX.get(0)+j] == 0) {
                    beenToX.add(0, currentX);
                    beenToY.add(0, beenToY.get(0)+j);
                    break;
                }
                if (map[beenToY.get(0)][beenToX.get(0)+j] == 2) {
                    beenToX.add(0, currentX);
                    beenToY.add(0, beenToY.get(0)+j);
                    solving = false;
                    break;
                }
            }
            if (i == 2) {
                if (map[beenToY.get(0)-j][beenToX.get(0)] == 0) {
                    beenToX.add(0, currentX);
                    beenToY.add(0, beenToY.get(0)+j);
                    break;
                }
                if (map[beenToY.get(0)-j][beenToX.get(0)] == 2) {
                    beenToX.add(0, currentX);
                    beenToY.add(0, beenToY.get(0)+j);
                    solving = false;
                    break;
                }
            }
            if (i == 3) {
                if (map[beenToY.get(0)][beenToX.get(0)-j] == 0) {
                    beenToX.add(0, currentX);
                    beenToY.add(0, beenToY.get(0)+j);
                    break;
                }
                if (map[beenToY.get(0)][beenToX.get(0)-j] == 2) {
                    beenToX.add(0, currentX);
                    beenToY.add(0, beenToY.get(0)+j);
                    solving = false;
                    break;
                }
            }
        }
    }
}

Then I realized I have a problem: How do I deal with the program handling multiple direction possibly at the same time? How about dealing with multiple correct routes?

It's also missing a section to check which tiles the player has already been to, to avoid running in circles.

Answer 1

Your movement rules might be unconventional, but it's still a classic pathfinding problem.

Dijkstra, A-star and all the rest work on any graph representation. So you just need to abstract yout movement away into a graph representation. At the most basic level, it only means each Node (State) links to a few other Nodes.

A pathfinder does not need to know yabout movement rules, it only needs a State representation like so:

public interface State extends Comparable<State>{
    List<? extends State> neighbours(); // Alternatively, return a Map<State, Integer> to associate a distance/cost
}

I assume you know how to code a Pathfinder class that matches this interface (otherwise look around on S:O):

public interface Pathfinder(){
    List<State> path(State start, State end);
}

In this case, here's what a resonable State implementation would look like for you:

public class RollingBallState extends Point implements State{

    private static map[][] map = [...];// This must be available somehow at the start, you decide how (hint: static var like I did is ugly AF)

    public RollingBallState(int xStart, int yStart){
         super(xStart, yStart);
    }

    @Override
    public List<RollingBallState> neighbours(){
        List<RollingBallState> neighbours = new ArrayList<>(4);
        int xLeft = getX(); // Where the ball can travel left
        for(int x=getX()-1; x>=0; x--){
            if(map[x][getY()] == 0){
                break;
            } else{
                xLeft = x;
            }
        }
        if(xLeft < xBall){
            neighbours.add(new RollingBallState(xLeft, getY()));
        }

        [...Get xRight, yUp, yDown, and add them in the same fashion ...]
        return neighbours;
    }

    @Override
    public int compareTo(RollingBallState other){
         if(getX() == other.getX()){
              return getY() - other.getY();
         } else {
              return getX() - other.getX();
         }
    }
}

You're all set up, just feed two RollingBallState (start & end) to your Pathfinder , it will give you the path.