Add penalties for turns to avoid staircasing in A* algorithm

[ivanmayes]

Refactored this from #32 into the src and added a configuration to set what the turn penalty is to enforce even more straight paths.

[cuixiping]

This PR doesn't work perfectly. For example:

In this case, the result is not the best path.

[cuixiping]

Refactored this from #32 into the src and added a configuration to set what the turn penalty is to enforce even more straight paths.

Can you review and fix the above issue ? @ivanmayes

[piotrmitrega]

Nice work! 👏 It actually solved the problem I had!

PS: The same logic could be applied for BiAStarFinder which gives you path with even less turns 😁

[MajesticGoodness]

Thanks so much for the fix. By itself, it works surprisingly well.

I'm trying to recreate the path finding of an old school game and added some tweaks to improve the behavior to match up with the expected result like @cuixiping pointed out.

In particular, when two moves are tied, this game's path finding prefers:

1. vertical movements before horizontal ones
2. prefers to move right instead of left
3. prefers to move up instead of down

I implemented a tiebreaker to be able to replicate these behaviors. I also added a momentum to paths, so that 'straighter' paths receive a small reward.

The 'solution,' if we can call it that, wasn't particularly pretty. I ended up doing the following:

1. Run A*.
2. Block the first tile that A* took in the last iteration.
3. Run A* again.
4. Now, compare the f-scores of the two paths. Return the path which has the lowest f-score.

I'm not sure if there's a way to coerce A* into taking the optimal path on the first iteration. I kept running into the problem where the algorithm would get tunnel-visioned on one particular path and completely ignore exploring the alternatives. A* will forsake considering a more optimal route if the route it's going down is 'optimal enough'. But many times that 'optimal enough' route isn't the one we want, and it often looks a lot like what @cuixiping posted.

On the bright side, I don't think there should be too much of a loss in performance with an extra iteration (hopefully). If your use case is a very large grid, you might see a bit of a slowdown.

Updated demo
Examples

Happy travels, fellow internet wanderer 👋

[cuixiping]

@MajesticGoodness
Could you show/share your game here?

I wrote a A* demo of finding shortest and least turns path years ago, and I may not be able to find the old code.
I used a different Grid/Node structure and consider the turns affect the heuristic value.

[MajesticGoodness]

@MajesticGoodness Could you show/share your game here?

I wrote a A* demo of finding shortest and least turns path years ago, and I may not be able to find the old code. I used a different Grid/Node structure and consider the turns affect the heuristic value.

I'm sorry to hear you haven't been able to locate your old source code. Sadly, I have none of my own to share.

I'm merely creating a bot for this particular game, and I needed to replicate its path finding so that my bot would know in advance which moves would be advantageous. The game is very dead and no one plays anymore 😔. My hope is to at least populate it with bots so that the few people who do still play have a slightly better experience.

If you are curious about the game, you can check out some game play footage here. Take care!

[cuixiping]

I found a demo file, you can take a look.
https://cuixiping.github.io/demo/astar-findpath-v3.html

[jodigiordano]

Suggested change

	* @param {number} opt.avoidStarcasing Add penalties to discourage turning and
	* @param {boolean} opt.avoidStaircase Add penalties to discourage turning and

[jodigiordano]

Suggested change

	lastDirection = node.parent === undefined? undefined : { x : node.x - node.parent.x, y : node.y - node.parent.y };
	var turned = lastDirection === undefined? 0 : lastDirection.x !== x - node.x || lastDirection.y !== y - node.y;
	lastDirection = node.parent === undefined ? undefined : { x: node.x - node.parent.x, y: node.y - node.parent.y };
	var turned = lastDirection === undefined ? 0 : lastDirection.x !== x - node.x || lastDirection.y !== y - node.y;

[jodigiordano]

Suggested change

	<label class="option_label">Avoid staircasing</label> <br>
	<label class="option_label">Avoid staircase</label> <br>