Using recursion to backtrack on a grid

i'll keep this concise. My problem is I generate a grid of dxd squares. In ever square on the grid there contains a random integer from 1 - (d-1). And there is one square containing a 0 (the goal). I randomly start on any square that is not the goal and I can move in ANY direction the amount of spaces of the square that I'm currently on (can't go out of bounds) and I need to use recursion to solve this problem. It also may be impossible to reach the goal with where I started and the layout of the grid.

I tried playing around with different algorithms and stumbled upon DFS, with what I have now, i'm not sure how to properly "backtrack" and avoid staying in an infinite loop. For instance if i start on a square with value 3, I'll move right 3 and if the square I moved to is 3 and I cant move right because its out of bounds so i'll go back left, then right, then left and so on.

if(finalArray[startPosX][startPosY] == 0) {
    System.out.println("we did it!");
    return true;
}
else {
    if(((startPosY + squareValue) <= boardSize-1))
        MovePlayer(startPosX, startPosY + squareValue); //Move right
        
    if(((startPosY - squareValue) >= 0))
        MovePlayer(startPosX, startPosY - squareValue); //Move left
        
    if(((startPosX + squareValue) <= boardSize-1))
        MovePlayer(startPosX + squareValue, startPosY); //Move down
        
    if(((startPosX - squareValue) >= 0))
        MovePlayer(startPosX - squareValue, startPosY); //Move up
}

This is my recursive method that will end up going in an infinite loop, I'd like some guidance with how to properly be able to not get stuck in a loop. How can I keep track of the previous square I was on and not go in the direction that will cause it to loop?

Thanks in advance!

There are two things that need to be done to fix your algorithm:

1. everytime you start walking into one path, you need to check the returned value to see if you have reached the goal, if you have, just return true, no need to try other paths (but if you want to find all possible paths, keep trying the rest paths).

2. mark the square as visited by converting it's value to be negative (or you can create a new array, for example, visitedArray, to mark visited squares if you don't want to or are not allowed to change the original array) to avoid going into infiniate loop:

if(finalArray[startPosX][startPosY] == 0) {
    System.out.println("we did it!");
    return true;
}
else {
    
    //already visited
    if(visitedArray[startPosX][startPosY]) return false;
 
    //mark this square as visited
    visitedArray[startPosX][startPosY] = true;

    boolean find = false;
    
    if(((startPosY + squareValue) <= boardSize-1))
        if(MovePlayer(startPosX, startPosY + squareValue)) find = true; //Move right, if goal can be reached, end recursion.
        
    if((!find && (startPosY - squareValue) >= 0))
        if(MovePlayer(startPosX, startPosY - squareValue)) find = true; //Move left
        
    if((!find && (startPosX + squareValue) <= boardSize-1))
        if(MovePlayer(startPosX + squareValue, startPosY)) find = true; //Move down
        
    if((!find && (startPosX - squareValue) >= 0))
        if(MovePlayer(startPosX - squareValue, startPosY)) find = true; //Move up

    //mark the square as unvisited, but to improve performance, 
    // you can delete this.
    visitedArray[startPosX][startPosY] = false;

    return find;
}