It is actually not a huge problem for me, because it occurs very rarely. However it may be good addition to your framework

You’re right that the current library can’t recognize this situation. A solution to this would be to have two A* instances running side by side (one going from start to end and one going from end to start) where you would stop the other instance if one instance can’t find a path. I don’t think the current implementation supports stopping calculations halfway, so I’d have to look into that. When I find some time, I’ll see if I can fix something up to help in your situation .

The Manhattan heuristic is pretty famous and explained well on wikipedia: http://en.wikipedia.org/wiki/Manhattan_distance. It basically counts the number of tiles you would have to move horizontally and the amount of tiles you would have to move vertically and adds the two. This is probably the most basic heuristic if you can’t move diagonally.

Hi Martin,

You can do this by giving water a higher cost in your map. In the example with the basic tile (http://www.dauntless.be/astar/overview/) the first argument is the cost of that tile. If you make it higher for water than land, it will prefer to walk on land.

it happens in the following scenario:

I have a initialized map 160×160 grid units;
I click on a grid unit that is walkable; but it is all surrounded by unwalkable grid units;

it then generates huge amount of iterations because I receive lag and path not found after 5-6 seconds.

I think this happens because the algorithm can’t figure out the tile is all blocked and it tries to iterate over the whole map to find a way to it.

Please give feedback

Thank you

I have a question – let’s say we have an archipelago with islands and water areas between them. The player can move either on land or water, but water has penalty when moved onto (the player moves slower). How to include logic that finds a way between two islands that contains as few water tiles as possible?

As far as I can see this is not what the AvoiderAnalyzer is for. I’m not sure even if any analyzer would do.

Thank you

As described there, if their movement is predictable, you can hack my classes and have it give the current path length as an argument to the Map class so that it can calculate if a tile will be walkable after x steps.

Another way would be to have cooperative path finding where every unit that searches for a path is aware of the paths of all the other units, but that’s quite a big step from my current implementation.