How to find an intercept on a moving target

Question

So here is my code roughly

Distance = Vector3.Distance(transform.position,Target.transform.position);
float timeToTarget; 
float burnDistance =  Projectile.MetersPerSecond * 2f * 2f * 0.5f;

if (Distance < burnDistance)
{
    timeToTarget = Mathf.Sqrt(2 * Distance / Projectile.MetersPerSecond);
}
else
{
    float velocity = Projectile.MetersPerSecond * 2;
    TimeToTarget = 2 + (Distance - burnDistance) / velocity;
}
AimPoint = Target.transform.position + (Target.transform.rigidbody.velocity * TimeToTarget) + (Random.insideUnitSphere * Accuracy);
Distance = Vector3.Distance(transform.position,AimPoint);
TimeToTarget = Mathf.Sqrt(2 * Distance / Projectile.MetersPerSecond);

i'm trying to intercept a target with a projectile.

The issue is finding the proper time to target I think.

Basically when I find the distance to target then use that to find the time to target it changes my aimpoint to where the target will be in time seconds. But now the distance has changed. Now i'm now longer distance to target away i'm distance to aimpoint away from what i want to hit.

Basically as the target moves away from me it takes longer for the projectile to hit the aimpoint than is predicted by distance to target. So I can fix this somewhat by running the algorithm again. Only using the aimpoint as the target and getting a closer approximation. I could keep doing this to get really close but that seems highly ineffiecient. Is there a better way?

score 1 · Answer 1 · answered Jul 19 '13 at 14:59

If you know the velocity vector V of the target, you can work out the velocity of the missile, and the time to intercept like this:

Suppose you are at P and the target is at Q. For a missile launched from P with velocity U to hit the target at time t we must have

P + t*U = Q + t*V

so

U = V + (Q-P)/t

Suppose that the missile speed -- the length of U -- is fixed at s so

s*s = V.V + 2*(Q-P).V/t + (Q-P).(Q-P)/(t*t)

or, rearranging)

(s*s - V.V)*t*t - 2*(Q-P).V*t - (Q.P).(Q-P) = 0

which is a quadratic equation for t. If there is a positive solution t0 to this, then you can launch a missile, with velocity U given by

U = V + (Q-P)/t0

to hit the target at time t0

Where did the equation `s*s = V.V + 2*(Q-P).V/t + (Q-P).(Q-P)/(t*t)` come from? Does it have a name? — jmrah, Jan 09 '20 at 14:05
The squared length of U is U.U; substitute the equation for U into this. — dmuir, Jan 09 '20 at 16:02

score 0 · Answer 2 · edited May 23 '17 at 10:33

If your "shooter" does not rotate and you just need to fire a projectile so that it intercepts the target, I suggest you look at the excellent answer by Jeffery Hantin in this post.

On the other hand, if your body rotates and then shoots and you want the projectile to intercept the target...that is a very different problem. In short, it starts out with the same two equations that you find in the above post, but you add in another equation for the arcos of the angle between the facing vector of the shooter and the final position you are aiming at. This leads to a somewhat nasty nonlinear and non-quadratic set of equations. I didn't solve them, but I did use a binary search to "squeeze" out the answer (or fail).

I have a much longer and more detailed description on a blog post, along with picture and video goodness, but I'll post the function (with generous comments) here.

Here is the function, with basic description, that I came up with:

/* Calculate the future position of a moving target so that 
 * a turret can turn to face the position and fire a projectile.
 *
 * This algorithm works by "guessing" an intial time of impact
 * for the projectile 0.5*(tMin + tMax).  It then calculates
 * the position of the target at that time and computes what the 
 * time for the turret to rotate to that position (tRot0) and
 * the flight time of the projectile (tFlight).  The algorithms
 * drives the difference between tImpact and (tFlight + tRot) to 
 * zero using a binary search. 
 *
 * The "solution" returned by the algorithm is the impact 
 * location.  The shooter should rotate towards this 
 * position and fire immediately.
 *
 * The algorithm will fail (and return false) under the 
 * following conditions:
 * 1. The target is out of range.  It is possible that the 
 *    target is out of range only for a short time but in
 *    range the rest of the time, but this seems like an 
 *    unnecessary edge case.  The turret is assumed to 
 *    "react" by checking range first, then plot to shoot.
 * 2. The target is heading away from the shooter too fast
 *    for the projectile to reach it before tMax.
 * 3. The solution cannot be reached in the number of steps
 *    allocated to the algorithm.  This seems very unlikely
 *    since the default value is 40 steps.
 *
 *  This algorithm uses a call to sqrt and atan2, so it 
 *  should NOT be run continuously.
 *
 *  On the other hand, nominal runs show convergence usually
 *  in about 7 steps, so this may be a good 'do a step per
 *  frame' calculation target.
 *
 */
bool CalculateInterceptShotPosition(const Vec2& pShooter,
                                    const Vec2& vShooter,
                                    const Vec2& pSFacing0,
                                    const Vec2& pTarget0,
                                    const Vec2& vTarget,
                                    float64 sProjectile,
                                    float64 wShooter,
                                    float64 maxDist,
                                    Vec2& solution,
                                    float64 tMax = 4.0,
                                    float64 tMin = 0.0
                                    )
{
   cout << "----------------------------------------------" << endl;
   cout << " Starting Calculation [" << tMin << "," << tMax << "]" << endl;
   cout << "----------------------------------------------" << endl;

   float64 tImpact = (tMin + tMax)/2;
   float64 tImpactLast = tImpact;
   // Tolerance in seconds
   float64 SOLUTION_TOLERANCE_SECONDS = 0.01;
   const int MAX_STEPS = 40;
   for(int idx = 0; idx < MAX_STEPS; idx++)
   {
      // Calculate the position of the target at time tImpact.
      Vec2 pTarget = pTarget0 + tImpact*vTarget;
      // Calulate the angle between the shooter and the target
      // when the impact occurs.
      Vec2 toTarget = pTarget - pShooter;
      float64 dist = toTarget.Length();
      Vec2 pSFacing = (pTarget - pShooter);
      float64 pShootRots = pSFacing.AngleRads();
      float64 tRot = fabs(pShootRots)/wShooter;
      float64 tFlight = dist/sProjectile;
      float64 tShot = tImpact - (tRot + tFlight);
      cout << "Iteration: " << idx
      << " tMin: " << tMin
      << " tMax: " << tMax
      << " tShot: " << tShot
      << " tImpact: " << tImpact
      << " tRot: " << tRot
      << " tFlight: " << tFlight
      << " Impact: " << pTarget.ToString()
      << endl;
      if(dist >= maxDist)
      {
         cout << "FAIL:  TARGET OUT OF RANGE (" << dist << "m >= " << maxDist << "m)" << endl;
         return false;
      }
      tImpactLast = tImpact;
      if(tShot > 0.0)
      {
         tMax = tImpact;
         tImpact = (tMin + tMax)/2;
      }
      else
      {
         tMin = tImpact;
         tImpact = (tMin + tMax)/2;
      }
      if(fabs(tImpact - tImpactLast) < SOLUTION_TOLERANCE_SECONDS)
      {  // WE HAVE A WINNER!!!
         solution = pTarget;
         return true;
      }
   }
   return false;
}

How to find an intercept on a moving target

2 Answers2