Help Using Path Finding Code

Question

Hi all.
I found some open source code which implements the A Star algorithm to achieve path finding for the purpose of navigating something in a game (although it could really be used for anything). Problem is, I can't get it to work. I've e-mailed the author but no reply yet so I was hoping someone could shed some light on my situation.
The code is meant to find a path on a 2 dimensional grid filled with obstacles using the following methods:
PathFinder star = new PathFinder(grid);
Path p = star.findShortest(startRow,startCol,goalRow,goalCol);
I've made a simple Test class with a small 2D array but when I compile the code I recieve the error:
Incompatible types.
Found: int.
Required: Test.Path
on Path p = star.findShortest(1,1,2,2);
I don't understand this error at all. The findShortest method takes 4 integers and I'm passing it 4 integers! Any ideas what this error means?
Here's my Test class:
import java.util.*;
import javax.swing.plaf.basic.*;
import java.awt.event.*;
import javax.swing.*;
import java.io.*;
import javax.swing.filechooser.*;
import java.util.Random;
public class Test
        public static void main(String args[])
                Test test = new Test();
                test.run();
       public final static class Path
                /** 2 for down, 0 is up, 1 is right and 3 is left */
                public int giveMove() {
                    if (size() < 2)
                        return -1;
                    Position last = (Position)positions.get(size() - 1);
                    Position forlast = (Position)positions.get(size() - 2);
                    if (forlast.col - last.col == 1)
                        return 2; //down
                    else if (forlast.col - last.col == -1)
                        return 0; //up
                    else if (forlast.row - last.row == 1)
                        return 1;//right
                    else if (forlast.row - last.row == -1)
                        return 3; //left
                    return -1;
                /** list of positions */
                public List positions;
                public int getCost() { return positions.size() - 1; }
                public int size() { return positions.size(); }
                public void add(Object o) { positions.add(o); }
                /** add (r,c) to the path */
                public void add(int r, int c) {
                    positions.add(new Position(r,c));
                /** get first position */
                public Position head() { return (Position) positions.get(0); }
                public Path(ArrayList positions) { this.positions = positions; }
                public Path(Position initial) {
                    positions = new ArrayList(1);
                    positions.add(initial);
                public Path(int cap) { positions = new ArrayList(cap); }
                public void set(Position front, Path old) {
                    positions.add(front);
                    Iterator i = old.positions.iterator();
                    while (i.hasNext())
                        positions.add(i.next());
        /** position on the grid */
       public static final  class Position
                public int row, col;
                public Position(int row, int col) {
                    this.row = row; this.col = col;
        public void run()
                System.out.println("Test");
                PathFinder star = new PathFinder(grid);
                for(int counter = 0; counter < grid.length; counter++)
                        for (int j=0; j < grid[counter].length; j++)
                                grid[counter][j] = 0;
                Path p = star.findShortest(1, 1, 2, 2);
     private static int[][] grid = new int[2][2];    
} Here's the PathFinder class I downloaded:
import java.util.*;
import javax.swing.plaf.basic.*;
import java.awt.event.*;
import javax.swing.*;
import java.io.*;
import javax.swing.filechooser.*;
import java.util.Random;
public final class PathFinder {
    /** the map grid to look on */
    private final int [][] grid;
    /** keep distances to each position here */
    private final int [][] distances;
    /** is gridposition (r, c) empty (empty is -1) ? */
    private boolean isEmpty(int r, int c) {
        return grid[r][c] == -1 ;
    /** pathfinder for grid */
    public PathFinder(int[][] grid) {
        this.grid = grid;
        this.distances = new int [grid.length][grid.length];
    /** clear distances */
    private void clear() {
        for (int i = 0 ; i < distances.length ; i++)
            for (int j = 0 ; j < distances.length ; j++)
distances[i][j] = Integer.MAX_VALUE;
/** position on the grid */
public final static class Position {
public int row, col;
public Position(int row, int col) {
this.row = row; this.col = col;
/** path from start to a certain position */
public final static class Path {
/** 2 for down, 0 is up, 1 is right and 3 is left */
public int giveMove() {
if (size() < 2)
return -1;
Position last = (Position)positions.get(size() - 1);
Position forlast = (Position)positions.get(size() - 2);
if (forlast.col - last.col == 1)
return 2; //down
else if (forlast.col - last.col == -1)
return 0; //up
else if (forlast.row - last.row == 1)
return 1;//right
else if (forlast.row - last.row == -1)
return 3; //left
return -1;
/** list of positions */
public List positions;
public int getCost() { return positions.size() - 1; }
public int size() { return positions.size(); }
public void add(Object o) { positions.add(o); }
/** add (r,c) to the path */
public void add(int r, int c) {
positions.add(new Position(r,c));
/** get first position */
public Position head() { return (Position) positions.get(0); }
public Path(ArrayList positions) { this.positions = positions; }
public Path(Position initial) {
positions = new ArrayList(1);
positions.add(initial);
public Path(int cap) { positions = new ArrayList(cap); }
public void set(Position front, Path old) {
positions.add(front);
Iterator i = old.positions.iterator();
while (i.hasNext())
positions.add(i.next());
/** gives the move to take for the shortest path from startRow to startCol
* 0 up, 1 right, 2 down, 3 left
* -1 if no move possible
public final int findShortest
(int startRow, int startCol, int goalRow, int goalCol) {
clear();
Position initial = new Position(startRow, startCol);
//LinkedList list = new LinkedList();
Position goal = new Position(goalRow, goalCol);
BinaireHoop list = new BinaireHoop(200, new Path(goal), goal);
list.add(new Path(initial));
Position [] successors = new Position[4];
int trie = 0;
for ( ; ! list.isEmpty() && trie < 10000 ; trie++) {
Path first = (Path) list.remove();
Position firstPos = first.head();
int r = firstPos.row; int c = firstPos.col;
if (r == goalRow && c == goalCol) {  //goal found !             
return first.giveMove();
} else {
int successorsCount = 0;
if (isEmpty(r-1,c)) {
successors[successorsCount++]
= new Position(r-1, c);
if (isEmpty(r+1,c)) {
successors[successorsCount++]
= new Position(r+1, c);
if (isEmpty(r,c-1)) {
successors[successorsCount++]
= new Position(r, c-1);
if (isEmpty(r,c+1)) {
successors[successorsCount++]
= new Position(r, c+1);
while (successorsCount-- > 0) {
Position succ = successors[successorsCount];
int newPathCost = first.getCost() + 1;
//add newPath if shorter than other path to this position
if (distances[succ.row][succ.col] > newPathCost) { //shorter
distances[succ.row][succ.col] = newPathCost;
Path newPath = new Path(newPathCost + 1);
newPath.set(succ, first);
//add path to binary heap
list.add(newPath);
} // else longer: discard
return -1;
There's also a BinaireHoop class which the PathFinder class uses. I'll post that code if anyone thinks it's relevant but the error appears to be soley on my implementation. The Path and Position and just small subclass which for the sake of quickness I just placed into my Test class too instead of into a new class to themselves.
Any thoughts appreciated! I would really like to get this working =)
Thanks.

Answer 1

Thanks for your reply. Doh, totally missed that one =)
Anyway, I got the code working but it's still very buggy. I think this must just be a problem with the PathFinder class I downloaded.
I create a 2D array
      int[][] array = {       
                              {-1, -1, -1, -1, -1, -1, -1, -1},          
                              {-1, -1, -1, -1, -1, -1, -1, -1},
                              {-1, -1, -1, -1, -1, -1, -1, -1},
                              {-1, -1, -1, -1, -1, -1, -1, -1},
                              {-1, -1, -1, -1, -1, -1, -1, -1},
                              {-1, -1, -1, -1, -1, -1, -1, -1},
                              {-1, -1, -1, -1, -1, -1, -1, -1},
                              {-1, -1, -1, -1, -1, -1, -1, -1}
                      };and choose starting and goal coordinates
int p = star.findShortest(1, 1, 2, 2);The PathFinder will generate the coordinates to move to (I just stuck it all in a loop and updated the starting coordinates as appropriate to lead me to the goal). This is great!
However, there seem to be a lot of bugs when I introduce "occupied squares". Basically, -1 in the array means that that square is empty whereas anything else means its full and the path finder should, in theory, generate a path around these obstacles. This isn't working correctly though.
Sometimes a path wil be found around the obstacle, sometimes the path will go straight through it, and many times it just throws an array index out of bounds exception error!
Anyone got any ideas? Or does anyone have any examples of a working path finder? =)
Cheers