How do I implement an A* pathfinding algorithm, with movement costs for every programming language?

Question

Can we get people to post code of simple, optimized implementations of the A* pathfinding algorithm, in every single language?

This is mostly for fun and to play with what stackoverflow itself is capable of... although I actually am interested in getting an ActionScript 3 version of this.

But the idea is that this "Question" will continue to be updated eternally into the future, even as different programming languages are created!

I don't know of any other place online where you can see pseudocode "translated" into many (much less every) different language. Seems like it's a worthwhile resource, and while not necessarily what this site was designed for, there's no harm in trying it out and seeing if it turns out to be a worthwhile thing that stackoverflow could be used for!

Answer 1

Here is a JavaScript implementation, along with source code and an online demo I did as a hobby/research project.

It is very simple, but you can change some of the params (grid size, # of walls, debugging info on/off). It will show you the calculated f(x), g(x), and h(x) values for each node that is inspected.

The demo page implementation uses jQuery.

Answer 2

Here's a C++ implementation. It's fairly well tested by now, and used in commercial video games and various AI projects.

http://code.google.com/p/a-star-algorithm-implementation/

And there's a tutorial, which I actually wrote first:

http://www.heyes-jones.com/astar.html

Answer 3

Here's a C# implementation done by one of the people who build the language.

Answer 4

Source codes and demos in different programming languages:

List of demo's for each language:

C++: 1
Java: 3
Processing: 1
Actionscript 3 (Flash): 4
Flex (Flash): 1
Javascript: 6
C#: 1
Ruby: 1
Prolog: 1
Unity: 1
Lua: 1

Pathfinding Demo in different languages

Enjoy :)

Answer 5

Not an implementation, but I found http://theory.stanford.edu/~amitp/GameProgramming/AStarComparison.html to be a particularly clear explanation of the algorithm. Has pseudocode that makes it very easy to implement, along with an extended review of various data structures that can be used for implementing the open & closed sets, a discussion of different heuristics that are applicable in different situations, modifications to heuristics to get specific behaviours (e.g. getting approximations of straight lines in systems that only support limited angles of movement), common pitfalls (e.g. using a heuristic with a different scale to the actual movement costs), and some optimizations (e.g. working with regions of uniform cost rather than a grid).

Answer 6

An AS 3 example... http://www.dauntless.be/astar/

Answer 7

I implemented A* in C as a way to learn C, so I can't promise it's beautiful, but it works! I used it to solve Project Euler #83 and it worked on two test cases.

https://github.com/PeterMitrano/A-star-Pathfinding/blob/master/problem_83.c

Answer 8

Python and C++ source code along with interactive tutorial. The code is written to work on graphs in general, and is not specific to grids (as you will find in many examples of A* on the web). It uses binary heaps for the priority queue (both Python and C++ have binary heaps in their standard libraries). I have Breadth First Search, Dijkstra's Algorithm, and A* on that page. The code is reasonably short (shorter than most A* sample code I find).

Answer 9

A Clojure implementation, heavily based on an example given in PAIP.

Answer 10

An optimized Java implementation is available in GraphHopper.

Answer 11

A VB6 implementation.

http://www.gandraxa.com/pathfinding_with_a_star.xml

This is particularly useful because you can step through the process and get a good understanding of how the algorithm works. This can be quite valuable when converting the algorithm to another language.