Pathfinding is a search problem commonly encountered in computer strategy games. The goal in pathfinding is to find the least cost path between two points on a map. The map is divided into a discrete cells, usually squares or hexagons. Typically there is cost associated with moving into a cell, which depends on the terrain in a cell. E.g. moving into a muddy square costs more than moving into a paved square. (You might consider why the cost is associated with moving into, rather than out of, a cell.)

In most games and many real world problems pathfinding in an informed search; the agent knows approximately where the goal is and can calculate heuristics like the straight line distance from any point to the goal. In games the pathfinding environment is usually treated as fully observable. If parts of the map are unknown the agent may only plan a route to the boundry of the observed region. If there are hidden obsticles, the agent typically picks a route ignoring them and must replan after finding them. (In some cases computer agents may be allowed to 'cheat' and observe more of the map than a human player would be allowed to.)

Although games are the most obvious application of pathfinding there are many other problems that require pathfinding. From pathfinding for actual robots (think ofthe Mars Rover) to less obvious problems, such as determing the path taken by water or oil flowing between underground resevoirs with different types of soil and rock impeding the flow.

Project: Test a number of different search strategies for pathfinding.

Algorithms: You will need to test the following algorithms:

• Breadth first.
• Greedy best first.
• A* with at least three different heuristics.

Experiments: For each algorithm you will need to do the following:

• Show that the algorithm works. In particular you should show, for each map, with an actual figure, both the cells explored by the algorithm and the route that the algorithm finds. Make sure that the figure clearly shows that the algorithm works. For example, if there is a mountain range that impedes movement show that the A* algorithm searches for a path around it.
• I will supply a number of maps (the format is given below) for testing your algorithms.

Other Rules: For this problem the map will use a rectangular grid. Agents will be able to move in four directions (up, down, left, right), but not diagonally.

Your program should be able to read a map file in the following format.
Width Height
StartX StartY
GoalX GoalY
map
Where the map is an array of characters. Width and Height define the width and height of the map. StartX, StartY, GoalX, and GoalY define the start and goal locations repectively. Note as a C++ programmer I have defined these positions starting from 0, so 0,0 is in the top lefthand corner of the map.
Here is a sample map file. The characters are interpreted as follows:

Character	Meaning	Movement Cost
R	road	1
f	field	2
F	forest	4
h	hills	5
r	river	7
M	mountains	10
W	water	can't be entered

After a successful search the program should be capable of the following:

• Draw the path on the map.
• Denote all of the explored squares on the map.
• Report the number of explored squares.

Write-up : Write your results as a paper. Plan on ~10 pages, including figures and graphs. The paper should include the following:

• An abstract summarizing what you did and what the results were.
• An introduction describing the pathfinding problem in general, and your specific version of it (e.g. the type of problem, the movement costs, etc.).
• An algorithms section that explains, in detail, the algorithms you used. Don't just say you used breadth first search - explain how it works. Remember to explain your A* heurisitcs.
• A results section that uses figures showing the discovered paths to show that the algorithms work as expected. Also include graphs or tables comparing the different algorithms' efficiency.
• The results sections should include results for each of the given maps, plus any you chose to invent.
• A conclusion section that discuss the advantages and weaknesses of the algorithms and heuristics you tried. You may also want to discuss variations that were not tried, e.g. how would allowing diagonal movements (possibly at aslightly higher cost) effect the results, what about hexagonal cells?