Members - Reputation: 137
Posted 19 September 2012 - 11:02 AM
Moderators - Reputation: 3411
Posted 19 September 2012 - 02:01 PM
Did you even bother to search this forum for "path smoothing"?
Professional consultant on game AI, mathematical modeling, simulation modeling
Co-advisor of the GDC AI Summit
Co-founder of the AI Game Programmers Guild
Author of the book, Behavioral Mathematics for Game AI
IA News - What's happening at IA | IA on AI - AI news and notes | Post-Play'em - Observations on AI of games I play
"Reducing the world to mathematical equations!"
Members - Reputation: 137
Posted 19 September 2012 - 02:36 PM
Members - Reputation: 977
Posted 29 September 2012 - 08:14 AM
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
theta_next = theta + w*dt
where "dt" is some small number.)
This is quick to code and gives pretty good results.