A* (pronounced A-star) requires that the area be known with the start and end point defined. Essentially, it then searches for the lowest cost route from A to B. The reason I say lowest cost and not shortest is that it is possible to define an areas or routes that are more difficult to cross and thus make them more costly routes, even though they may be shorter.

Firstly, you must split the environment into nodes. These can be any size or shape. For this example I’m using, I’m splitting the environment into squares 10×10. These nodes can be passable or blocked. Travelling from one node to another has a cost associated with it. Travelling horizontally or vertically could have a weight of 1.0 while diagonal moves are 1.4. These weights can be used to approximate environmental hazards or difficulties to deter the algorithm from selecting it as a path.

This screenshot shows the start conditions of the environment. The black nodes are blocked and the path will search from green to red.

As you can see there are several different routes available. This algorithm does not allow diagonal moves and all moves have a cost of 1. Turning also has an additional cost of 1.

Each node requires 3 values, G, H and F.

1. H is a heuristic estimate to the goal. It is the estimated cost to reach the target node, it does not take into account the individual costs of the nodes in-between or the presence of any blocked nodes. This can be precomputed for every node or calculated when needed.
2. G is the cost to reach the current node from the start location. This is calculated as the algorithm runs.
3. F is the sum of H and G

The algorithm maintains 2 lists of nodes while it runs, an open list and a closed list. Both are initially empty.

The open list is nodes that are available to be moved to, the closed list are nodes that have already been checked.

Once it starts, the current node is initialised to the start node, in this case [0,0]. All passable, adjacent nodes, that are not on the closed list, are then checked, in this case [1,0].

If the node is already on the open list, then its G value is calculated assuming the current node as the parent. This is done because the route to that node may be cheaper going through the current node than through its previous parent. If this is the case, the G value is updated and the current node is set as the parent.

If the node is not already on the open list, then the current node is set as its parent and the G value calculated.

If at this point, the open list is empty, then there is no possible route as there are no new nodes to move to. Otherwise, the node on the open list with the lowest F value is set as the current node and the loop starts over, the current node is removed from the open list and added to the closed list. This continues until the current node is the end node.

Once that has happened. The path can be found by tracking backwards through the nodes’ parents. The nodes that are passed through represent the lowest cost route between the start and end nodes.

The following links are downloads to the code and executable of the sample in the screenshot above. It is C# for Visual Studio 2008/2010.

Note: There is a file embedded within this post, please visit this post to download the file.

public Result Request()
{
}

public void RequestAsync(object userState)
{
	Task.Factory.StartNew(() =>
	{
		try
		{
			Result result = Request();
			RequestCompleted(this, new RequestEventArgs(result, userState));
		}
		catch (Exception e)
		{
			RequestCompleted(this, new RequestEventArgs(e, userState));
		}
	});
}

for every single request. So I made a generic solution. My first problem was that every request returns a different data type, depending on what the request was.

I had to make my event handler delegate and event args class both use generics.

public delegate void ResponseEventHandler<TResponse>(
	object sender,
	ResponseEventArgs<TResponse> e);

public class ResponseEventArgs<TResponse>: EventArgs
{
	public ResponseEventArgs(TResponse response, object userState)
	{
		this.Response = response;
		this.UserState = userState;
	}

	public ResponseEventArgs(Exception exception, object userState)
	{
		this.Exception = exception;
		this.UserState = userState;
	}

	public TResponse Response { get; private set; }
	public Exception Exception {get; private set; }
	public object UserState { get; private set; }
}

Finally, I wanted this easy to use. There are hundreds of different request methods in my library and I don’t want to have to write loads of code for them all.

I ended up making use of delegates to wrap the entire process up in a method that I can call from my Async methods.

Looking at the RequestAsync method above, all I have is the call to the synchronous method, then raising the event. There is a different event for each request. Both of these can be specified as delegate parameters.

protected void ExecuteAsync<TResponse>(
	Func<TResponse> executeRequest,
	ResponseEventHandle<TResponse> eventHandler,
	object userState)
{
	Task.Factory.StartNew(() =>
	{
		try
		{
			TResponse result = executeRequest();
			this.RaiseEvent(
				eventHandler,
				new ResponseEventArgs<TResponse>(result, userState));
		}
		catch (Exception e)
		{
			this.RaiseEvent(
				eventHandler,
				new ResponseEventArgs<TResponse>(e, userState));
		}
	});
}

private void RaiseEvent<TResponse>(
	ResponseEventHandler<TResponse> eventHandler,
	ResponseEventArgs<TResponse> e)
{
	if (eventHandler != null)
	{
		eventHandler(this, e);
	}
}

My RequestAsync method then becomes

public void RequestAsync(object userState)
{
	this.ExecuteAsync(this.Request, this.RequestCompleted, userState);
}

By writing a method to handle the actual web request and processing the response (de-serialising JSON in this case) in a similar manner, I was able to make the synchronous methods a single line of code as well. This saved me a lot time writing dozens of very similar functions. For a long time, I never used generics outside of data structures like List<> but using generics like this can save a lot of time writing repetitive and tedious code.