Алгоритм Java DepthFirstSearch не работает

Я попытался написать алгоритм поиска в глубину для решения лабиринта. Это то, что у меня есть до сих пор. Я постарался добавить как можно больше деталей, чтобы логика была понятна:

//Upgraded dfs algorithm that creates an array of nodeclass objects

package depthfirstsearch;

public class DepthFirstSearch {

    public static void main(String[] args) {
       
        int[][] stateArr = 
        {
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
        {0, 2, 0, 0, 1, 1, 1, 0, 1, 0, 0, 0, 1, 0, 0, 1, 1, 1, 0, 0},
        {0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0},
        {0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 0},
        {0, 1, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0},
        {0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0},
        {0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 0, 0},
        {0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0},
        {0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0},
        {0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0},
        {0, 1, 0, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0},
        {0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0},
        {0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0},
        {0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0},
        {0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0},
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0},
        {0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0},
        {0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0},
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0},
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}};
        //Maze array declaration
        
        int mazeRows = stateArr.length;
        int mazeCols = stateArr[0].length;
        
        //Creates an array of NodeClass objects
        NodeClass[][] mazeArr = new NodeClass[mazeRows][mazeCols];
        
        //Assigning values to the nodes (state, isPath, coords)
        for(int i = 0; i < mazeRows; i++)
        {
            for(int j = 0; j < mazeCols; j++)
            {
                int state = stateArr[i][j];
                mazeArr[i][j] = new NodeClass(i, j, state);    //Assigning coordinates & state (wall, path) to the node              
            }   //End of col for-loop            
        }   //End of row for-loop
        
        //Currently have an array of nodes with coordinates, state and isPath = false
        
        NodeClass currentNode = mazeArr[1][1];  //This is the node we'll be working with. Assigned the value of the starting node at position (1;1)
 
        
        while(currentNode.getState() != 3)  //3 Indicates the end of the maze. While we haven't reached the end
        {
            //Getting the position of the current node
            int row = currentNode.getNodeRow();
            int col = currentNode.getNodeCol();
            System.out.println("Run");
            System.out.println(currentNode);
            
            //We'll be taking the currentNode and checking every unchecked adjacent node:

            //Check up
            if ((mazeArr[row-1][col].getState() == 1 || mazeArr[row-1][col].getState() == 3) && (mazeArr[row-1][col].haveTried() == false))
            {
                //Storing the parent node:
                NodeClass temp = currentNode;   //Stores the current node as the node temp
                mazeArr[row-1][col].setParentNode(temp); //Stores the current node as the parent node the new checked node
                
                mazeArr[row][col].setTried(true);   //Sets the current node as tried
                mazeArr[row][col].setIsPath(true);  //Considers the current node as a potential path

                currentNode = mazeArr[row-1][col];  //The new current node is the node above the original node

                System.out.println("Up");   //We moved up
            }
            
            //Check right
            else if ((mazeArr[row][col+1].getState() == 1 || mazeArr[row][col+1].getState() == 3) && (mazeArr[row][col+1].haveTried() == false))
            {
                //Storing the parent node:
                NodeClass temp = currentNode;   //Stores the current node as the node temp
                mazeArr[row-1][col].setParentNode(temp); //Stores the current node as the parent node the new checked node
                
                mazeArr[row][col].setTried(true);   //Sets the current node as tried
                mazeArr[row][col].setIsPath(true);  //Considers the current node as a potential path

                currentNode = mazeArr[row][col+1];  //The new current node is the node above the original node

                System.out.println("Right");   //We moved right
            }
            
            //Check down
            else if ((mazeArr[row-1][col].getState() == 1 || mazeArr[row-1][col].getState() == 3) && (mazeArr[row-1][col].haveTried() == false))
            {
                //Storing the parent node:
                NodeClass temp = currentNode;   //Stores the current node as the node temp
                mazeArr[row-1][col].setParentNode(temp); //Stores the current node as the parent node the new checked node
                
                mazeArr[row][col].setTried(true);   //Sets the current node as tried
                mazeArr[row][col].setIsPath(true);  //Considers the current node as a potential path

                currentNode = mazeArr[row][col+1];  //The new current node is the node above the original node

                System.out.println("Down");   //We moved down
            }
            
            //Check left
            else if ((mazeArr[row][col-1].getState() == 1 || mazeArr[row][col-1].getState() == 3) && (mazeArr[row][col-1].haveTried() == false))
            {
                //Storing the parent node:
                NodeClass temp = currentNode;   //Stores the current node as the node temp
                mazeArr[row-1][col].setParentNode(temp); //Stores the current node as the parent node the new checked node
                
                mazeArr[row][col].setTried(true);   //Sets the current node as tried
                mazeArr[row][col].setIsPath(true);  //Considers the current node as a potential path

                currentNode = mazeArr[row][col+1];  //The new current node is the node above the original node

                System.out.println("Left");   //We moved left
            }
            
            //If there are no paths left: we reached a dead end and need to back track
            else
            {
                mazeArr[row][col].setTried(true);   //Sets the current node as tried
                mazeArr[row][col].setIsPath(false); //Since it's a dead end, we remove it from the potential solution

                currentNode = mazeArr[row][col].getParentNode();    //Sets the current node as the previous node    
            }
            
        }   //End of while-loop for fining the solution
        
        System.out.println("Yay yay, we did it!");
        
    }   //End of main method
    
}   //End of DepthFirstSearch Class

Проблема в том, что я получаю сообщение об ошибке: Исключение в потоке «main» java.lang.NullPointerException: невозможно вызвать «Deepfirstsearch.NodeClass.getState()», поскольку «currentNode» имеет значение NULL.

Я распечатал узел currentNode, но обнаружил, что на самом деле он не равен нулю. В чем может быть проблема? Буду признателен за любые советы. Спасибо.