/*
The Map Class, One is given to each Entity.
The Map is used to "remember" where that Entity has been

PathFinding will use this.
*/

   import java.util.ArrayList;
   import java.awt.Point;
   import java.util.HashSet;
   import java.util.Set;
   import java.util.List;

   public class Map
   {
      private PathPoint[][] blocks;
      private int xSize;
      private int ySize;
      private boolean isDead = false;
      private ArrayList<ArrayList<Point>> uniquePoints;
      private int stockD;
      Map(int xSizes, int ySizes)
      {
      //set size then construct!
         xSize = xSizes;
         ySize = ySizes;
         stockD = (xSize*ySize*2);
         construct();
      }
      //Astar Added.
      public int getRows()
      {
         return ySize;
      }
      public int getCols()
      {
         return xSize;
      }
      public PathPoint getTileAt(final Point loc)
      {
         return blocks[loc.x][loc.y];
      }
      public Set<PathPoint> getTilesAround(final Point location)
      {
         final Set<PathPoint> nearTiles;
         //final int       middleRow;
         //final int       middleCol;
     
         nearTiles = new HashSet<PathPoint>();
         ArrayList<PathPoint> sides = getOpenSides(blocks[location.x][location.x]);
         for(int k = 0; k < sides.size(); k++)
            nearTiles.add(sides.get(k));
         /*
         middleRow = location.getRow();
         middleCol = location.getCol();
     
         for(int row = middleRow - 1; row <= middleRow + 1; row++)
         {
            for(int col = middleCol - 1; col <= middleCol + 1; col++)
            {
               final PathPoint tile;
           
               if(row < 0 || col < 0)
               {
                  continue;
               }
               
               if(row >= ySize-1 || col >= xSize-1)
               {
                  continue;
               }
           
               if(row == middleRow && col == middleCol)
               {
                  continue;
               }
           
               tile = blocks[row][col];
               nearTiles.add(tile);
            }
         }
         */
       
         return (nearTiles);
      }
      /*
      private Path getPath(PathPoint start, PathPoint goal)
      {
         final PathFinder finder;
         final Path       path;
         final List<PathPoint> tiles;
         finder = new AStar(new SimpleHeuristicCalculator(getRows() * getCols()));
         path   = finder.findPath(this, start.getLocationz(), goal.getLocationz());
     
         System.out.println("pathed: "+path);
         
         if(path == null)
         {
            vzy.UI.PopUp.popup("Null Path Error: Now Exiting");
            System.exit(0);
         }
         
         return path;
         //path.Tiles() = "Current > Goal"
      }//*/
    //End Additions
      private void construct()
      {
      //make the blocks then fill it with new cells
         blocks = new PathPoint[xSize][ySize];
         for(int x = 0; x < blocks.length; x++)
            for(int y = 0; y < blocks[x].length; y++)
               blocks[x][y] = new PathPoint(new Point(x,y), new Cell(), stockD);
               
               //make the uniquePoints
         uniquePoints = new ArrayList<ArrayList<Point>>();
         for(int k = 0; k < 5; k++)
         {
            if(k < 2)
               uniquePoints.add(null);//why would we want walls and floors in this?
            else
               uniquePoints.add(new ArrayList<Point>());
         }
      }
      public void died()
      {
      //is the entity in the act of dieing? (because we toke so long makeing the path, it's the only way they die right now!)
         isDead = true;
      }
      public void close()
      {
      //closing method, used to keep memory low, System.gc() is called in the caller of this method.
      //world.hasBecomeDead() > world.eh.isDeadNow() > Entity.close() > item/map.close()
      //world.hasBecomeDead() calls the garbage collector.
     
      //clear blocks
         for(int x = 0; x < blocks.length; x++)
         {
            for(int y = 0; y < blocks[x].length; y++)
            {
               blocks[x][y].close();
               blocks[x][y] = null;
            }
            blocks[x] = null;
         }
         
         //clear uniques
         for(int k = 0; k < uniquePoints.size(); k++)
            if(uniquePoints.get(k)!=null)
            {
               uniquePoints.get(k).clear();
            }
         uniquePoints.clear();
         uniquePoints = null;
      }
      private void updateUnique(Cell newC, Cell oldC, Point p)
      {
      //if the old one is a unique cell then dump it from the list
         if(oldC.getCode() > 1)
         {
         //find the cell first >.>
            ArrayList<Point> ps = uniquePoints.get(oldC.getCode());
            boolean found = false;
            for(int k = 0; !found && k < ps.size(); k++)
               if(ps.get(k).equals(p))
               {
               //now dump it.
                  ps.remove(k);
                  found = true;
               }
         }
         //if the new one is unique, add it
         if(newC.getCode() > 1)
            uniquePoints.get(newC.getCode()).add(p);
      }
      public void set(java.awt.Point p, Cell c)
      {
      //updating Cells ^^
     
      //if the code is different, then update the uniques!
         if(blocks[p.x][p.y].cell.getCode() != c.getCode())
            updateUnique(c, blocks[p.x][p.y].cell, p);
           
            //set the cell into it's new home
         blocks[p.x][p.y].cell.set(c);//copies the new cell into it's self
         blocks[p.x][p.y].cell.unTake();//makes sure there is no people on it, it's for a map (maps don't show people on them!)
      }
      public void makePathToFood(ArrayList<Integer> path, Point start) throws World.DirectionException, World.NoGoalException
      {
     
      //code for food is 3, go to it.
         if(!isDead)
            makePathToCode(3, path, start);
      }
      public void makePathToWater(ArrayList<Integer> path, Point start) throws World.DirectionException, World.NoGoalException
      {
     
      //code for water is 2, go to it.
         if(!isDead)
            makePathToCode(2, path, start);
      }
      private PathPoint findGoal(int code, Point start, ArrayList<PathPoint> avoiders) throws World.NoGoalException
      {
     
      //I recently came up with this, after a good 80% of the pathfinding-making time passed...
     
      //get the points that are the goals we want
         ArrayList<Point> goals = uniquePoints.get(code);
         {
            int k = 0;
            while(k < goals.size())
            {
               boolean good = true;
               for(int j = 0; j < avoiders.size(); j++)
                  if(goals.get(k).equals(avoiders.get(j)))
                  {
                     good = false;
                     goals.remove(k);
                  }
               if(good)
                  k++;
            }
         }
         if(goals.size() <= 0)
            throw new World.NoGoalException();
         int shortestGoal = 0;
         double shortestGoalLength = 99999.9;//should be increased?
         
         //go through all of them and find the shortest.
         for(int k = 0; k < goals.size(); k++)
            if(start.distance(goals.get(k))<shortestGoalLength)
            {
               shortestGoalLength = start.distance(goals.get(k));
               shortestGoal = k;
            }
           
            //return shortest.
         return blocks[goals.get(shortestGoal).x][goals.get(shortestGoal).y];
      }
      private ArrayList<PathPoint> getPath(PathPoint start, PathPoint end) throws World.CanNotFindGoalException
      {
         /*for(int k = 0; k < blocks.length; k++)
            for(int j = 0; j < blocks[k].length; j++)
               blocks[k][j].clear();//*/
         start.path2Home.add(start);
         PathPoint current = start;
         ArrayList<PathPoint> next = new ArrayList<PathPoint>();
         //ArrayList<PathPoint> opened = new ArrayList<PathPoint>();
         while(!current.equals(end))
         {
         //opened.add(current);
            ArrayList<PathPoint> open = getOpenSides(current);
            for(int k = 0; k < open.size(); k++)
               if(current.path2Home.size()==1)
               {
                  //is start
                  open.get(k).path2Home.add(current);
                  next.add(open.get(k));
               }
               else
               {
                  if(open.get(k).path2Home == null)
                  {
                  //found start
                  }
                  else
                     if(open.get(k).path2Home.size() == 0)
                     {
                     //no path to home;
                        open.get(k).path2Home.addAll(current.path2Home);
                        open.get(k).path2Home.add(current);
                        next.add(open.get(k));
                     }
                     else
                     {
                     //has path to home
                        if((current.path2Home.size()+1) < open.get(k).path2Home.size())
                        {
                        //current is better
                           open.get(k).path2Home.clear();
                           open.get(k).path2Home.addAll(current.path2Home);
                           open.get(k).path2Home.add(current);
                           next.add(open.get(k));
                        }
                     }
               }
            if(next.size() == 0)
               throw new World.CanNotFindGoalException();
            current = next.get(0);
            next.remove(0);
         }
         current.path2Home.add(end);
         return current.path2Home;
      }
      private void path2(Point beginning, int code, ArrayList<Integer> path) throws World.DirectionException, World.NoGoalException
      {
         path2(beginning, code, path, new ArrayList<PathPoint>());
      }
      private void path2(Point beginning, int code, ArrayList<Integer> path, ArrayList<PathPoint> avoidGoals) throws World.DirectionException, World.NoGoalException
      {
            //We are not on it, it was worth a try :(
         if(isDead)
            return;
               
               //add the start cell
         PathPoint start = blocks[beginning.x][beginning.y];
                 
               //Find the closest goal cell
         PathPoint end = findGoal(code, beginning, avoidGoals);
         if(isDead)
            return;
                 
            //Path routez = getPath(start,end);
            //ArrayList<PathPoint> route = routez.Tiles();
         ArrayList<PathPoint> route = null;
         try
         {
            route = getPath(start,end);
         }
            catch(World.CanNotFindGoalException cnfge)
            {
               avoidGoals.add(end);
               path2(beginning, code, path, avoidGoals);
            }
         if(route != null)
            for(int k = 0; k < (route.size()-1); k++)
               path.add(direction(route.get(k), route.get(k+1)));
            //path.Tiles() = "Current > Goal"
      }
      public void makePathToCode(int code, ArrayList<Integer> path, Point beginning) throws World.DirectionException, World.NoGoalException
      {
         {
            if(Main.DEBUG)
               System.out.println("Map.makePathToCode-0");
            if(isDead)
               return;
           
            //Clear All cells for next path-finding
            for(int x = 0; x < blocks.length; x++)
               for(int y =0; y<blocks[x].length; y++)
                  blocks[x][y].clear();
               
               //Set a stocknumber, a default d
            int stockNum = blocks[2][2].d;
            if(Main.DEBUG)
               System.out.println("Map.makePathToCode-1");
           
            //Check if we are on it
            if(blocks[beginning.x][beginning.y].cell.getCode() == code)
            {
           
            //we are on it!
               if(Main.DEBUG)
                  System.out.println("Map.makePathToCode-2-A-0");
               if(isDead)
                  return;
               
               //lets move once in an open direction and move back
               PathPoint b = getOpenSides(blocks[beginning.x][beginning.y]).get(0);
               PathPoint ac = blocks[beginning.x][beginning.y];
               if(Main.DEBUG)
                  System.out.println("Map.makePathToCode-2-A-1");
               if(isDead)
                  return;
               
               //add the moves into the path list
               path.add(direction(ac,b));
               path.add(direction(b,ac));
               if(Main.DEBUG)
                  System.out.println("Map.makePathToCode-2-A-Done");
            }
            else
            {
            //check to see if we are one block away, will crash.
               boolean oneAway = false;
               ArrayList<PathPoint> test = getOpenSides(blocks[beginning.x][beginning.y]);
               for(int k = 0; k < test.size(); k++)
                  if(test.get(k).cell.getCode() == code)
                  {
                     oneAway = true;
                     path.add(direction(blocks[beginning.x][beginning.y],test.get(k)));
                  }
               if(oneAway == false)
                  path2(beginning, code, path);
            }
         }
         System.gc();
               
               //WTF happens from here?!?!?
               //after days of shearching I made my own... that kills if to far form goal.
               
               //Find path to Start From End
               //The Way we use: grow out on all open sides, growing a number on each growth of the 'wave'
               /*
               Example:
               0 = end point.
               s = start Point
               
                     6
                    656
                   65456
                  s543456
                 654323456
                65432123456
               6543210123456
                65432123456
                 654323456
                  6543456
                   65456
                    656
                     6
               /
            {
               int startNum = start.d;
               if(isDead)
                  return;
                 
                  //our end is 0 blocks away.
               int x = 0;
               end.d = x;
               
               //we are no longer on the end block, add one (we are going one away)
               x++;
               if(isDead)
                  return;
               if(Main.DEBUG)
                  System.out.println("Map.makePathToCode-2-B-2");
                 
                  //get all of the open blocks next to the current (end right now)
               ArrayList<PathPoint> current = getOpenSides(end);
               if(Main.DEBUG)
                  System.out.println("Map.makePathToCode-2-B-3");
               if(isDead)
                  return;
                 
                  //While we have not changed the starting cell's d
               while(start.d==startNum && !isDead)
               {
               //PathFinding, explode out from end.
                  if(Main.DEBUG)
                     System.out.println("Map.makePathToCode-2-B-4");
                     
                     //set all d's on the current to our distance from the end, if it's a stock number (will crash without check)
                  for(int k = 0; (k < current.size())&&(start.d==startNum)&& !isDead; k++)
                  {
                     if(current.get(k).d == stockNum)
                        current.get(k).d = x;
                  }
                  if(Main.DEBUG)
                     System.out.println("Map.makePathToCode-2-B-5");
                  if(isDead)
                     return;
                     //while we still have cells from the 'wave' in current, remove them after adding their open cells to the current
                  while(current.get(0).d<=x)
                  {
                     ArrayList<PathPoint> asdf = getOpenSides(current.get(0));
                     if(isDead)
                        return;
                     current.addAll(asdf);   
                     current.remove(0);
                  }
                  if(Main.DEBUG)
                     System.out.println("Map.makePathToCode-2-B-6");
                     
                     //the wave just went one step out from the end, time to add a counter.
                  x++;
               }
            }
            if(isDead)
               return;
            {
           
            //Follow the Lowest numbered D back to home
           
               if(Main.DEBUG)
                  System.out.println("Map.makePathToCode-2-B-7");
                 
            //start has a number, look for one less then it, then loop
               int num = start.d;//fun fact, i am start.d steps away from the end point!
               
               //current point (p)
               PathPoint p = start;
               if(Main.DEBUG)
                  System.out.println("Map.makePathToCode-2-B-8: Num: "+num);
               if(isDead)
                  return;
                 
                  //while current point is not the end
               while(p.d > 0 && !isDead)
               {
                  if(Main.DEBUG)
                     System.out.println("Map.makePathToCode-2-B-9: p.d: "+p.d+">0?");
                     
                     //we get the open sides
                  ArrayList<PathPoint> pp = getOpenSides(p);
                  if(isDead)
                     return;
                  boolean found = false;
                  if(Main.DEBUG)
                     System.out.println("Map.makePathToCode-2-B-10: pp.size(): "+pp.size());
                     
                     //we go through the current sides of our current spot till we get closer
                  for(int k = 0; (k < pp.size())&&(!found)&&!isDead; k++)
                  {
                     if(Main.DEBUG)
                        System.out.println("Map.makePathToCode-2-B-11: pp[k].d: "+pp.get(k).d);
                       
                        //if one is closer to home then we are now
                     if(pp.get(k).d < num)
                     {
                        if(Main.DEBUG)
                           System.out.println("Map.makePathToCode-2-B-12");
                        found = true;
                        if(isDead)
                           return;
                           //add the move direction to the path list
                        path.add(direction(p,pp.get(k)));
                       
                        //then we are the lowest so far ^^
                        p = pp.get(k);
                        num = p.d;
                        if(Main.DEBUG)
                           System.out.println("Map.makePathToCode-2-B-13");
                           
                           //loop till we are at the end.
                           
                        /* //this is here to see the map, at each step on the way home, useless here?
                        {
                           for(int y = 0; y < ySize; y++)
                           {
                              for(int x = 0; x < xSize; x++)
                              {
                                 System.out.print("["+blocks[x][y].cell.getCode()+":"+blocks[x][y].d+"]");
                              }
                              System.out.println("");
                           }
                           System.out.println("Beginning: "+beginning);
                           //System.exit(83);
                        }
                        ///
                     }
                  }
               }
            }
         }
         if(isDead)
            return;
         if(Main.DEBUG)
            System.out.println("Map.makePathToCode-3");
           
            //we got our path, now lets clean up
         for(int x = 0; x < blocks.length; x++)
            for(int y =0; y<blocks[x].length; y++)
               blocks[x][y].clear();
         if(Main.DEBUG)
            System.out.println("Map.makePathToCode-Done");
           
            //done.
      /*
      Cells are in a (x,y) order
      Cells have a getCode() method
      Codes in cells are:
         0: basic wall
         1: basic floor
         2: basic water
         3: basic food
      zero or less means you can't travel on that cell.
      first cell found with the code we want is used to make a path with.
      path is a list of move commands
      move commands (All are int):
         World.NORTH
         World.EAST
         World.SOUTH
         World.WEST
      Example:
         00000
         011G0
         01000
         0S110
         00000
         
         Path for S to G = World.NORTH,World.NORTH,World.EAST,World.EAST
      */
      }
      private ArrayList<PathPoint> getPathPointsAround(PathPoint p, int r)
      {
         if(isDead)
            return null;
           
            //get the points around us
         ArrayList<Point> ps = World.getPointsAround(p, r);
         if(isDead)
            return null;
           
            //and convert them to pathpoint, excluding the "out of bounds" ones
         ArrayList<PathPoint> pp = new ArrayList<PathPoint>();
         for(int k = 0; k < ps.size(); k++)
            try
            {
               pp.add(blocks[ps.get(k).x][ps.get(k).y]);
            }
               catch(ArrayIndexOutOfBoundsException aioobe)
               {
               }
         return pp;
      }
      private int direction(Point a, Point b) throws World.DirectionException
      {
     
      //what direction would I have to go from a to b? {north,south,east, or west}
     
         if((a.x == b.x) && (a.y+1 == b.y))
            return World.NORTH;
         else
            if((a.x+1 == b.x) && (a.y == b.y))
               return World.EAST;
            else
               if((a.x == b.x) && (a.y-1 == b.y))
                  return World.SOUTH;
               else
                  if((a.x-1 == b.x) && (a.y == b.y))
                     return World.WEST;
                  else
                     throw new World.DirectionException();
      }
      private ArrayList<PathPoint> getOpenSides(PathPoint pp)
      {
         ArrayList<PathPoint> newP = new ArrayList<PathPoint>();
         if(isDead)
            return null;
           
            //add the side of the current cell to the list.
         newP.add(blocks[pp.x+1][pp.y]);
         newP.add(blocks[pp.x-1][pp.y]);
         newP.add(blocks[pp.x][pp.y+1]);
         newP.add(blocks[pp.x][pp.y-1]);
         if(isDead)
            return null;
         int k = 0;
         while(k < newP.size())
         {
         //remove the walls (they are not open!)
            if(newP.get(k).cell.getCode()<=0)
            {
               newP.remove(k);
            }
            else
               k++;
         }
         return newP;
      }
      static class PathPoint extends Point
      {
         public int d;
         public Cell cell;
         public final int stock;
         public ArrayList<PathPoint> path2Home;
         PathPoint(int base)
         {
            this(new Point(0,0), new Cell(), base);
         }
         PathPoint(Point p, Cell c, int base)
         {
            super(p);
            cell = c;
            stock = base;
            path2Home = new ArrayList<PathPoint>();
         }
         public void clear()
         {
            d = stock;
            if(path2Home != null)
               path2Home.clear();
            else
               path2Home = new ArrayList<PathPoint>();
         }
         public void close()
         {
            path2Home.clear();
            path2Home = null;
            cell.close();
            cell = null;
         }
         public boolean canWalk()
         {
            return cell.getCode() > 0;
         }
         public Point getLocationz()
         {
            return this;
         }
         public final int hashCode()
         {
            return super.hashCode();
         }
         public final boolean equals(final Object o)
         {
            final boolean retVal;
         
            if(this == o)
            {
               return (true);
            }
         
            if(o instanceof PathPoint)
            {
               final PathPoint other;
           
               other  = (PathPoint)o;
               retVal = (x==other.x) && (y==other.y);
            }
            else
            {
               retVal = false;
            }
         
            return (retVal);
         }
     
         public String toString()
         {
            return super.toString() + " -> " + cell.getCode();
         }
      }
   }

boolean oneAway = false;
               ArrayList<PathPoint> test = getOpenSides(blocks[beginning.x][beginning.y]);//gets the cells that we can walk to, that are also open to walk on. (not walls)
               for(int k = 0; k < test.size(); k++)
                  if(test.get(k).cell.getCode() == code)//if one of them is the thing we want
                  {
                     oneAway = true;
                     //move to it.
                     path.add(direction(blocks[beginning.x][beginning.y],test.get(k)));
                  }
               if(oneAway == false)//are we one block away?
                  path2(beginning, code, path);

for(int k = 0; k < (route.size()-1); k++)
               path.add(direction(route.get(k), route.get(k+1)));

finder = new AStar(new SimpleHeuristicCalculator(getRows() * getCols()));
path = finder.findPath(this, start.getLocationz(), goal.getLocationz());

ArrayList<PathPoint> goals = unique.get(code); //returns all the goals of the type we want.
int shortest;
double shortestD = big number.
for(int k = 0; k < goals.size(); k++)
if(goals.get(k).distance(start)<shortestD)
{
shortest = k;
shortestD = goals.get(k).distance(start);
}
return goals.get(shortest);

Exception in thread "Thread-6" java.lang.OutOfMemoryError: Java heap space
   at java.util.Arrays.copyOf(Arrays.java:2772)
   at java.util.Arrays.copyOf(Arrays.java:2746)
   at java.util.ArrayList.ensureCapacity(ArrayList.java:187)
   at java.util.ArrayList.add(ArrayList.java:378)
   at Map.path2(Map.java:324)

class Node implements Comparable<Node>{
   public boolean isOccupied=false; //is this node impassable
   public int g=99999; //distance so far
   public int h=0; //heuristic
   public int x=0, y=0;
   public Node prev; //storing the previous node in the path allows us to calculate the final path by starting at the goal and reading out the previous nodes until we hit the start
   public boolean closed=false; //is this node in the closed list? it's simpler and faster to mark nodes as closed than maintain a closed list
   public void reset(){ //this will reset the internal values, this must be called before a new path-finding attempt
      g=99999; h=0; isPath=false; closed=false;
   }
   public Node(){}
   public Node(int x, int y){this.x=x; this.y=y;}
   //the following is important! if you make the nodes comparable then you can use a priority queue for your open list, which is much more efficient and also solves some other problems.
   public boolean equals(Node b){ //returns whether these are in fact the same node
      if (b.x==x && b.y==y) return true;
      else return false;
   }
   public int compareTo(Node o) { //returns the difference between the total costs of the two nodes
      return (g+h-o.g-o.h);
   }
}

public Node[][] AStarMap = new Node[17][13];
public LinkedList<Node> foundPath;

private int getManhattan(int x1, int y1, int x2, int y2){
   return Math.abs(x1 - x2) + Math.abs(y1 - y2);
}

public void findPath() {

   Point2D.Float destination = p.getPosition(); //destination
   Point2D.Float op = getPosition(); //our position
   
   //populate the AStarMap
   for (int i=0; i<AStarMap.length; i++){
      for (int j=AStarMap[i].length-1; j>=0; j--){
         AStarMap[i][j].reset();
         AStarMap[i][j].isOccupied = /*someway of telling if block is occupied*/;
         AStarMap[i][j].closed = AStarMap[i][j].isOccupied; //close all nodes that are impassable
         AStarMap[i][j].x = i;
         AStarMap[i][j].y = j;
      }
   }
   
   LinkedList<Node> path = new LinkedList<Node>();
   Node goal = AStarMap[(int)destination.x/64][(int)destination.y/64]; //64 is the tilesize
   Node start= AStarMap[(int)op.x/64][(int)op.y/64];
   goal.isPath = true; //these two nodes are obviously part of the correct final path
   start.isPath = true;
   start.g=0;
   start.h=getManhattan(start.x, start.y, goal.x, goal.y);
   goal.prev = start;
   PriorityQueue<Node> openList = new PriorityQueue<Node>();
   openList.add(start);
   while (!openList.isEmpty()){
      //get node with lowest f-val (top item), and put it in the closed list
      Node top = openList.poll(); //this is the huge advantage of using a priority queue
      if (top.closed) continue;
      else top.closed = true; // as soon as a node has been processed, MARK it as closed
      //if we pop the goal node then stop and trace back the path
      if (top.equals(goal)){ //popping the goal node means we've successfully found a path
         Node toAdd = goal; //start at the goal and trace backwards
         do{
            path.addFirst(toAdd); //add the node
            toAdd = toAdd.prev;  //move the pointer to the previous node in the path
         }while (toAdd!=start);   //keep on tracing the path until we hit the beginning
         break; //break from the loop once we've traced the path
      }
      //add in adjacent nodes to the open list, if they're not closed
      // calculate their g and h values before adding them to the open list
      // and also setting their prev pointer to the current node for tracing
         if (top.x>0 && !AStarMap[top.x-1][top.y].closed && ((AStarMap[top.x][top.y].g+1) < AStarMap[top.x-1][top.y].g)){
            AStarMap[top.x-1][top.y].g = AStarMap[top.x][top.y].g+1;
            AStarMap[top.x-1][top.y].h = getManhattan(top.x-1, top.y, goal.x, goal.y);
            AStarMap[top.x-1][top.y].prev = top;
            openList.add(AStarMap[top.x-1][top.y]);
         }
         
         if (top.y>0 && !AStarMap[top.x][top.y-1].closed && ((AStarMap[top.x][top.y].g+1) < AStarMap[top.x][top.y-1].g)){
            AStarMap[top.x][top.y-1].g = AStarMap[top.x][top.y].g+1;
            AStarMap[top.x][top.y-1].h = getManhattan(top.x, top.y-1, goal.x, goal.y);
            AStarMap[top.x][top.y-1].prev = top;
            openList.add(AStarMap[top.x][top.y-1]);
         }
         
         if ((top.x<AStarMap.length-1) && !AStarMap[top.x+1][top.y].closed && ((AStarMap[top.x][top.y].g+1) < AStarMap[top.x+1][top.y].g)){
            AStarMap[top.x+1][top.y].g = AStarMap[top.x][top.y].g+1;
            AStarMap[top.x+1][top.y].h = getManhattan(top.x+1, top.y, goal.x, goal.y);
            AStarMap[top.x+1][top.y].prev = top;
            openList.add(AStarMap[top.x+1][top.y]);
         }
         
         if ((top.y<AStarMap[0].length-1) && !AStarMap[top.x][top.y+1].closed && ((AStarMap[top.x][top.y].g+1) < AStarMap[top.x][top.y+1].g)){
            AStarMap[top.x][top.y+1].g = AStarMap[top.x][top.y].g+1;
            AStarMap[top.x][top.y+1].h = getManhattan(top.x, top.y+1, goal.x, goal.y);
            AStarMap[top.x][top.y+1].prev = top;
            openList.add(AStarMap[top.x][top.y+1]);
         }
   }
   
   foundPath = path;
}

            try
            {
               path.add(direction(beginning,route.get(0)));
               while(true)
               {
                  path.add(direction(route.get(0), route.get(1)));
                  route.remove(0);
               }
            }
               catch(ArrayIndexOutOfBoundsException aioobe)
               {
               }
               catch(IndexOutOfBoundsException ioobe)
               {
               }

            try
            {
               while(true)
                  path.add(direction(route.get(0), route.get(1)));
            }
               catch(ArrayIndexOutOfBoundsException aioobe)
               {
               }