public static ArrayList<BasicNode> GetPath(LevelEntity[][] level, BasicNode start,BasicNode goal){
		int[][]  temp = {{ 1,-1},
				 { 1,-2},
				 { 2,-2},
				 { 2,-3},
				 { 3,-3},
				 { 3,-4},
				 { 4,-4},
				 { 5,-3},
				 { 6,-3},
				 { 7,-3},
				 { 8,-2},
				 { 8,-1}};
		int[][]  temp2 = {{ 1,-1},
				 { 1,-2},
				 { 1,-3},
				 {1,-4},
				 { 2,-4}};
		longJumpLocations = temp;
		shortJumpLocations = temp;
		HashSet<BasicNode> closedSet = new HashSet<BasicNode>();
		Hashtable<BasicNode,BasicNode> cameFrom = new Hashtable<BasicNode,BasicNode>();
		Hashtable<BasicNode,Double> gScore =new Hashtable<BasicNode,Double>();
		Hashtable<BasicNode,Double> fScore =new Hashtable<BasicNode,Double>();
		BasicNode[][] nodeGrid = new BasicNode[level.length][level[0].length];

		PriorityQueue<BasicNode> openSet = new PriorityQueue<BasicNode>(500,new BasicComparator(fScore));
		
		nodeGrid[start.xx][start.yy] = start;
		nodeGrid[goal.xx][goal.yy] = goal;
		
		gScore.put(start, 0.0);
		
		fScore.put(start, (double) (goal.xx - start.xx));
		
		openSet.add(start);
		
		while (openSet.size() > 0){
			BasicNode current = openSet.poll();
			if (current == goal){
				ArrayList<BasicNode> path = new ArrayList<BasicNode>();
				while (current != start){
					path.add(current);
					current = cameFrom.get(current);
				}
				return path;//reconstructPath(cameFrom,goal);
			}
			
			closedSet.add(current);
			
			for (BasicNode neighbor : getNeighbors(current,level,nodeGrid)){
				if (!closedSet.contains(neighbor)){
					double tentativeGScore = gScore.get(current) + getDistance(current,neighbor);
					if (!openSet.contains(neighbor) || tentativeGScore < gScore.get(neighbor)){
						cameFrom.put(neighbor, current);
						gScore.put(neighbor, tentativeGScore);
						fScore.put(neighbor, tentativeGScore + goal.xx-neighbor.xx);
						if (openSet.contains(neighbor)){
							openSet.remove(neighbor);
						}
						openSet.add(neighbor);
					}
				}
			}
		}
		
		
		return null;		
	}