• Advertisement
Sign in to follow this  

Smoothing a path calculated by A*

This topic is 1942 days old which is more than the 365 day threshold we allow for new replies. Please post a new topic.

If you intended to correct an error in the post then please contact us.

Recommended Posts

Hi everyone. I need to know if there is any way to smooth a path gained from the standard A*. I store the path as indces of each tile of the grid into a std::list<unsigned int>. I've actually read the article "Toward More Realistic Pathfinding" in Gamasutra but since the sample code is not available, it's hard for me to understand it correctly. so I would be grateful if someone could help me on this. thank you.

Share this post

Link to post
Share on other sites
yes I did. both on on the web and this forum. but almost everywhere they would refer to the article I mentioned above. otherwise I would never start a new topic for this. If there is anything I'm missing please just let me know.

Share this post

Link to post
Share on other sites
It sounds like the pathfinding algorithm described in "Toward More Realistic Pathfinding" is a bit complicated for your purposes.

I think the easiest solution is a feedback controller that's willing to "cut corners." Here's a nice one that's not too complicated:

Keep track of two points:
- Where the agent is. Call this point x.
- The point furthest along the path that the agent can see in a straight line. Call this point p.

At every frame,
1. Advance p along the path until just before x cannot see it. (On most frames, p will not move.)
2. Walk x towards p.

It's not the most efficient method -- it requires a bunch of raycasts that fancier computational geometry algorithms like "string pulling" avoid -- but it's simple; it's flexible; and you can start out with a very basic implementation and then "slot in" improvements.

For step 1, you can do one of,
- sequential search
- binary search (you could use std::lower_bound to do this by saying that a point p on the path is "less than" a point x if it is visible from x.)
- step-doubling forward search, followed by binary search (i.e., try the point one ahead of p; then two ahead, then four ahead, then eight ahead, and so-on, until you encounter a point that's not visible; then do binary search on the interval between the last two points. Like binary search, this has logarithmic worst-case complexity, but the average-case will be better if the point you're looking for is usually not very far ahead of the one you're at).

For step 2, if you want smooth turns, you can simulate the following ODE:

(This part simulates a "turn-on-a-dime" car with sped s and turning rate w:)

dx/dt = s [cos(theta); sin(theta)];
dtheta/dt = w;


(This part is the controller for the car that determines its speed and turning rate.)

s = v1 cos(theta) + v2 sin(theta)
w = v1 sin(theta) - v2 cos(theta)

and v = (v1, v2) is the vector from x to p; i.e., v = p - x.

(By "simulate" I mean do e.g. Euler integration; e.g., when I write

dtheta/dt = w

I mean

theta_next = theta + w*dt

where "dt" is some small number.)

This is quick to code and gives pretty good results.

Share this post

Link to post
Share on other sites
Sign in to follow this  

  • Advertisement