title: Unable to implement A Star in java
body: <p>I've been trying all day to get this algorithm up and running, but I cant for the life of me. I've read many tutorials on the net, and source code in AS3, javascript, and C++; but I cannot adapt what I am seeing to my own code. </p>
  
  <p>I have created an AStar class that has a nested class named Node. The map is a 2D array named MAP.</p>
  
  <p>The biggest problem that I am having is pulling the F value in the pathfind function.</p>
  
  <p>I have implemented the F = G + H, my problem is the actual AStar algorithm. Can someone please help, this is how far I've got as of yet:</p>
  
  <pre><code>import java.util.ArrayList;
  
  public class AStar
  {
      int MAP[][];
  
      Node startNode, endNode;
  
      public AStar(int MAP[][], int startXNode, int startYNode,
                                int endXNode, int endYNode)
      {
          this.MAP = MAP;
          startNode = new Node(startXNode, startYNode);
          endNode = new Node(endXNode, endYNode);
      }
  
      public void pathfinder()
      {
          ArrayList openList = new ArrayList();
          ArrayList closedList = new ArrayList();
  
  
  
      }
  
      public int F(Node startNode, Node endNode)
      {
          return (H(startNode, endNode) + G(startNode));
      }
  
      //H or Heuristic part of A* algorithm
      public int H(Node startNode, Node endNode)
      {
          int WEIGHT = 10;
          int distance = (Math.abs(startNode.getX() - endNode.getX()) + Math.abs(startNode.getY() - endNode.getY()));
  
          return (distance * WEIGHT);
      }
  
      public int G(Node startNode)
      {
          if(MAP[startNode.getX() - 1][startNode.getY()] != 1)
          {
              return 10;
          }
  
          if(MAP[startNode.getX() + 1][startNode.getY()] != 1)
          {
              return 10;
          }
  
          if(MAP[startNode.getX()][startNode.getY() -1] != 1)
          {
              return 10;
          }
  
          if(MAP[startNode.getX()][startNode.getY() + 1] != 1)
          {
              return 0;
          }
  
          return 0;
      }
  
      public class Node
      {
          private int NodeX;
          private int NodeY;
  
          private int gScore;
          private int hScore;
          private int fScore;
  
          public Node(int NodeX, int NodeY)
          {
              this.NodeX = NodeX;
              this.NodeY = NodeY;
          }
  
          public int getX()
          {
              return NodeX;
          }
  
          public int getY()
          {
              return NodeY;
          }
  
          public int getG()
          {
              return gScore;
          }
  
          public void setG(int gScore)
          {
              this.gScore = gScore;
          }
  
          public int getH()
          {
              return hScore;
          }
  
          public void setH(int hScore)
          {
              this.hScore = hScore;
          }
  
          public int getF()
          {
              return fScore;
          }
  
          public void setF(int fScore)
          {
              this.fScore = fScore;
          }
      }
  }
  </code></pre>
  
  <p>This is the furthest I can ever get with the pathfinder function:</p>
  
  <pre><code>   public void pathfinder()
      {
          LinkedList&lt;Node&gt; openList = new LinkedList();
          LinkedList&lt;Node&gt; closedList = new LinkedList();
  
          Node currentNode;
  
          openList.add(startNode);
  
          while(openList.size() &gt; 0)
          {
              currentNode = (Node) openList.get(0);
              closedList.add(currentNode);
  
  
              for(int i = 0; i &lt; openList.size(); i++)
              {
                  int cost = F(currentNode, endNode);
  
              }
          }
  
      }
  </code></pre>