Pathfollowing with acceleration - centripetal force

Question

I'm implementing A* waypoint pathfinding with some twists. One of the problems I'm encountering is because I do not change velocities of the agents directly but rather I do so through forces.

Which gives me the following problem: let's suppose the path consists of three nodes,

P0 = the starting position P1 = node 1 P2 = node 2

When the agent starts moving, it's first target position is P1. The agents moves in that direction because I let a force F act on it's velocity: F=normalized(targetPos-agentPos)*agentAccel*agentMass;

The agent reaches P1.

Now the agent's target position is P2, and upon it will act a force in the direction of (targetPos-agentPos).

However, this is a centripetal force, meaning that the agent will most likely orbit around P2 instead of popping the next node off the path (unless the angle between [P0,P1] and [P1,P2] is small) Stopping the agent at each node is not an option (would look unnatural) What should really happen is the velocity of the agent gradually shifting towards 100% the direction of [targetPos-agentPos], and the velocity should be completely 'shifted' before a certain distance(dX) is laid off, starting from the previous node position

In order to solve this problem, only one parameter is adjustable:

• F_dir: the direction of the force acting upon the agent, that's supposed to lead the agent to the next node.

The values of the following parameters are known:

• agentAcceleration (=the magnitude of the force vector)
• agentVelocity
• agentPosition
• node positions
• targetPosition (= the next node on the path)

I've been trying some different strategies with trial and error to prevent this, but it seemed rather messy, so my question is, what is a decent approach to this problem?

Answer 1

As much as I can tell you can use beizer curves to smooth the path. I know it's not physical at all, but just create a beizer curve with order of 2, from each three points in the path. this way character will not path exactly over all the waypoints but it'll move over a path which can be an actual physical shape's path. you can also check for the collision along the way to solve issues about the object moving through the walls, since beizer curves will go through the wall.

Answer 2

Note: know that with constant acceleration your speeds will soon become ludicrous if the path is even moderately straight.

Mode 1: Cheat. Use the path points to define a hermite spline then use velocity and acceleration to define how fast, it will look reasonable to audiences brought up on Star Wars and Battlestar Galactica physics. (this is basically faking sideways friction)

Mode 2: Cheat less. Realize that passing directly through the path points is not necessary, allowing a radius to trigger arrival will stop the orbiting behavior you are talking about.

Mode 2.5: (I think this will work) You left out current direction of movement, in physics terms "velocity" is simply a speed. Take the direction your agent is currently moving and that's vector V1, now take the direction directly to the new point and call that vector V2. Get the angle between V1 and V2 and create a vector V3 that is -angle from V1 and this will be your F_dir vector. Note that it does not point directly at the next point, but appears to over-compensate by pushing too far - but that's self correcting because over time V1 will approach a heading directly at the next point.

Mode 2.5a: Since your acceleration is constant and the agent's velocity is constantly changing the real angle to move your force's direction vector won't be as I described in 2.5 above but instead will have to over and under compensate based on relative velocity versus force, but that's beyond my math to describe beyond that. (ie. a very slow agent doesn't require as much angle to get headed the right way, while a very fast one would require extreme measures to bring into line).