Physics Predictions: Catching AI & Drag Forces

//Only recalculate the refined drag direction when asked for
if (_isRefined)
    return _direction;

//Calculate firing solution, and get initial landing position guess
int sign = (_dragLandingPos.x < 0 || _dragLandingPos.z < 0) ? -1 : 1;
int signT = (Target.position.x < 0 || Target.position.z < 0) ? -1 : 1;
float distanceToDragLanding = (_dragLandingPos - LaunchPos.position).magnitude * sign;
float distanceToTarget = (Target.position - LaunchPos.position).magnitude * signT;
float distanceDiff = Mathf.Abs(distanceToDragLanding) - Mathf.Abs(distanceToTarget);

//If our initial guess isn't too far from the landing position with drag -> use initial direction and speed
if (Mathf.Abs(distanceDiff) < DragMargin + float.Epsilon)
{
    _isRefined = true;
    _speed = _speedBeforeRefinedDrag;
    return _direction;
}

//Binary search to ensure closer trajectory to target
float minBound = 0;
float maxBound = 0;

//Forward vector to target
Vector3 fwdDirection = _direction;
fwdDirection.y = 0;
fwdDirection = fwdDirection.normalized;

//Angle from forward vector to target to the direction vector in radians
float angle = Vector3.Angle(fwdDirection, _direction) * Mathf.Deg2Rad;
if (distanceDiff > 0)
{
    //Maximum bound -> use shortest possible shot as minimum bound
    maxBound = angle;
    minBound = -Mathf.PI / 2f;

    //Create new rotated direction
    Vector3 dirCopy = _direction;
    Vector3 newDir = Quaternion.AngleAxis(minBound * Mathf.Rad2Deg, fwdDirection) * dirCopy;

    //Calculate new landing pos and check if it's close enough in distance to target
    Vector3 landingPos = CalculatePositionWithDragForce(_totalTime, newDir);
    landingPos.y = 0.01f;
    float distanceToLandPos = (landingPos - LaunchPos.position).magnitude * sign;
    float diff = Mathf.Abs(distanceToLandPos) - Mathf.Abs(distanceToTarget);

    //If so, use this as direction
    if (Mathf.Abs(diff) < DragMargin + float.Epsilon)
    {
        _isRefined = true;
        return newDir;
    }   
}
else
{
    bool keepLoop = true;
    while (keepLoop)
    {
        //Need to check for maximum bound here
        minBound = angle;
        maxBound = Mathf.PI / 4f;

        //Create new rotated direction
        Vector3 dirCopy = _direction;
        Vector3 newDir = Quaternion.AngleAxis(maxBound * Mathf.Rad2Deg, fwdDirection) * dirCopy;
        
        //Calculate new landing pos and check if it's close enough in distance to target
        Vector3 landingPos = CalculatePositionWithDragForce(_totalTime, newDir);
        landingPos.y = 0.01f;
        float distanceToLandPos = (landingPos - LaunchPos.position).magnitude * sign;
        float diff = Mathf.Abs(distanceToLandPos) - Mathf.Abs(distanceToTarget);

        //If so, use this as direction
        if (Mathf.Abs(diff) < DragMargin + float.Epsilon)
        {
            _isRefined = true;
            return newDir;
        }

        //If not, check if we can get closer to the target with best possible angle we rotated with (45degrees)
        //By increasing the speed 
        if (diff < 0)
        {
            if (_iterationCounter == 0)
                SetSpeed(1f);

            //Need to increase the force in that case, and retry until we get it right
            SetSpeed(_speed + 1);
            ++_iterationCounter;
            if (_iterationCounter < _maxIterations)
            {
                continue;
            }
            else
            {
                //If it seems we can't even get it right even by increasing the force, just reset it and mark as invalid shot
                _iterationCounter = 0;
                SetSpeed(_speedBeforeRefinedDrag);
                _isRefined = true;
                success = false;
                return _directionBeforeRefinedDrag;
            }
        }
        else
        {
            keepLoop = false;
        }
    }
}

//We have a min and max bound -> so search for something inbetween that will fit the margin
Vector3 closestDir = _direction;
float rDist = DragMargin * 1000f;

_iterationCounter = 0;
while (Mathf.Abs(rDist) < DragMargin + float.Epsilon)
{
    _iterationCounter++;
    float a = (maxBound - minBound) / 2f;

    //Keep rotating the direction from min- to max-bound
    Vector3 dirCopy = _direction;
    closestDir = Quaternion.AngleAxis(a * Mathf.Rad2Deg, fwdDirection) * dirCopy;

    //Calculate new landing pos and check if it's close enough in distance to target
    Vector3 landingPos = CalculatePositionWithDragForce(_totalTime, closestDir);
    landingPos.y = 0.01f;
    float dist = (landingPos - LaunchPos.position).magnitude * sign;
    rDist = Mathf.Abs(dist) - Mathf.Abs(distanceToTarget);

    //Adjust boundaries of search
    if (rDist < 0)
        minBound = angle;
    else
        maxBound = angle;

    //Stop searching after an amount of tries and mark is invalid
    if (_iterationCounter > _maxIterations)
    {
        success = false;
        _isRefined = true;
        return closestDir.normalized;
    }
}

//Otherwise return successful direction
_isRefined = true;
return closestDir.normalized;