Help with tile pathfinding

Question

I have been wanting to create a game for some time and have just recently started trying to get path finding to work. I have come up with code that works once(it will get one tile closer to the goal then stay at that node) but i can not figure out how to get it to go all the way to the goal node. can someone point out the problem area or possible fixes for me?
(my code is too long look in the next post for the rest of it)
package pathfinding;
import java.awt.Graphics;
import java.util.LinkedList;
import mainPackage.Main;
* call this class to find a path between start node and goal node
@SuppressWarnings("serial")
public class PathFinder extends LinkedList {
     public LinkedList<Node> openList = new LinkedList<Node>();
     public LinkedList<Node>closedList = new LinkedList<Node>();
     public LinkedList<Node> pathList = new LinkedList<Node>();
     int D = 4;
     public Node[][] nodeBoard=new Node[15][15];
     private Object lowestF;
     public PathFinder(int tilesX, int tilesY) {
               for(int y = 0; y < tilesY; y++) {
                    for(int x = 0; x < tilesX; x++) {
                         Node n = new Node(x, y, 0, 0);
                         nodeBoard[x][y] = n;
                         //System.out.println("nodeBoard["+x+"]["+y+"]: "+n);
     public void findPath(Node startNode, Node goalNode) {
          System.out.println("started pathfinding ");
          Node n = startNode;
          Node gn = goalNode;
          Node lowestF = null;
          if(openList.contains(n) == false)
               openList.add(n);//add the current node to the open list
          //for(int time = 0; time < 10; time++) {//used for testing purposes
          //while(closedList.contains(goalNode) != true) {//while the goal node isnt on the closed list
          while(lowestF != goalNode) {
          //System.out.println("started the while loop  gn x:"+gn.X+" gn y:"+gn.Y);
          //System.out.println("n X:"+n.X+" n Y:"+ n.Y);
          if(closedList.contains(gn) == false) {
               //System.out.println("closedList does not contain goalNode");
          if(lowestF != null) {//if it isnt the first time doing the loop
               n = lowestF;//switch lowestF to the current node (n)
               lowestF = null;// the node with the lowest f score
               //System.out.println(""+closedList.contains(nodeBoard[n.X-1][n.Y-1]));
          System.out.println("printing n "+n);
          

Answer 1

here is the rest of my code from above
System.out.println(""+nodeBoard[n.X-1][n.Y-1]);
          ///ads the surrounding nodes if they are not on the closed list or on the open list already
          if(closedList.contains(nodeBoard[n.X-1][n.Y-1]) == false ){// && (openList.contains(nodeBoard[n.X-1][n.Y-1]) == false))
          openList.add(nodeBoard[n.X-1][n.Y-1]);}//1//these add the nodes surrounding the current node to open list
          if(closedList.contains(nodeBoard[n.X][n.Y-1]) == false){// && openList.contains(nodeBoard[n.X][n.Y-1]) == false)
          openList.add(nodeBoard[n.X][n.Y-1]);}  //2   1 | 2 | 3
          if(closedList.contains(nodeBoard[n.X+1][n.Y-1]) == false){// && openList.contains(nodeBoard[n.X+1][n.Y-1]) == false)
          openList.add(nodeBoard[n.X+1][n.Y-1]);}//3   4 | X | 5
          if(closedList.contains(nodeBoard[n.X-1][n.Y]) == false){// && openList.contains(nodeBoard[n.X-1][n.Y]) == false)
          openList.add(nodeBoard[n.X-1][n.Y]);}  //4   6 | 7 | 8
          if(closedList.contains(nodeBoard[n.X+1][n.Y]) == false){// && openList.contains(nodeBoard[n.X+1][n.Y]) == false)
          openList.add(nodeBoard[n.X+1][n.Y]);}  //5
          if(closedList.contains(nodeBoard[n.X-1][n.Y+1]) == false){// && openList.contains(nodeBoard[n.X-1][n.Y+1]) == false)
          openList.add(nodeBoard[n.X-1][n.Y+1]);}//6
          if(closedList.contains(nodeBoard[n.X+1][n.Y+1]) == false){// && openList.contains(nodeBoard[n.X+1][n.Y+1]) == false)
          openList.add(nodeBoard[n.X+1][n.Y+1]);}//8
          if(closedList.contains(nodeBoard[n.X][n.Y+1]) == false){// && openList.contains(nodeBoard[n.X][n.Y+1]) == false)
          openList.add(nodeBoard[n.X][n.Y+1]);}  //7
          nodeBoard[n.X-1][n.Y-1].setParent(n);//
          nodeBoard[n.X][n.Y-1].setParent(n);  //Sets the parents to the current node
          nodeBoard[n.X+1][n.Y-1].setParent(n);//
          nodeBoard[n.X-1][n.Y].setParent(n);  //
          nodeBoard[n.X+1][n.Y].setParent(n);  //
          nodeBoard[n.X-1][n.Y+1].setParent(n);//
          nodeBoard[n.X][n.Y+1].setParent(n);  //
          nodeBoard[n.X+1][n.Y+1].setParent(n);//
          openList.remove(n);//remove the current node from the open list
          closedList.add(n);//add to the closed list
          for(int a = 0; a < openList.size(); a++) {//for all the nodes in the open list
               Node s = (Node) openList.get(a);//just set a to s for no apparent reason so far
               s.h = D * Math.max(Math.abs(s.X-gn.X), Math.abs(s.Y-gn.Y));//this finds the Heuristic
               //System.out.println("testing h: "+s.h);
               s.setG(s.getParent().getG()+10);//sets the g of the current node by getting the g of the parent and adding in the cost of movement(10)
          for(int fc = 0; fc < openList.size(); fc++) {//compare current node(s) to all other nodes in the open list to find the lowest f score
               Node ff = (Node) openList.get(fc);//turns the counter into a node reference
               //System.out.println("ff's f value: "+ff.getF());
               if(lowestF == null) {//if there isnt a lowest f so far make one
               lowestF = ff;
               //System.out.println(" comparing lowest f's: "+lowestF.compareF(ff));
               if(lowestF.compareF(ff)> 0) {//if ff's f score is lower then lowestF's ff is the new lowestF
                    lowestF = ff;
                    //System.out.println("found new lowest f");
          if(lowestF == null) {
               System.out.println("found lowest f and breaking out of loop to stop error");
               break;
          openList.remove(lowestF);//remove the lowestF node from open list
          //System.out.println("removed lowestF from open list "+lowestF);
          closedList.add(lowestF);//add the lowestF node to the closed list
          //System.out.println("added lowestF to closed list "+lowestF);
          pathList.addLast(lowestF);
          //System.out.println("added lowestF to path list "+lowestF);
          n = lowestF;//set the lowestF node to the new "start" node
          if(closedList.contains(gn) == false) {
               //System.out.println("closedList does not contain goalNode");
          for(int ol = 0; ol < openList.size(); ol++) {
               //System.out.println("openList: "+openList.get(ol).toString());
          for(int cl = 0; cl < closedList.size(); cl++) {//used to show the nodes in closed and open lists
               //System.out.println("closedList: "+closedList.get(cl));
          for(int pl = 0; pl < pathList.size(); pl++) {
               //System.out.println("path: "+pathList.get(pl).toString());
          //System.out.println("goalNode must be on the closed list");
}