Modules/BehaviorControl/CommonXabsl2Symbols/BallSymbols.cpp

Go to the documentation of this file.

/** 
* @file BallSymbols.cpp
*
* Implementation of class BallSymbols.
*
* @author Martin Lötzsch
*/

#include "BallSymbols.h"
#include "Tools/Math/Geometry.h"
#include "Tools/FieldDimensions.h"
#include "Modules/BallLocator/GT2005BallLocatorParameters.h"

BallSymbols::BallSymbols(const BehaviorControlInterfaces& interfaces) : 
BehaviorControlInterfaces(interfaces), 
playBallPrecisely(false),
ballPrecision(0),
ballCanBeIntercepted(false),
interceptionAlreadyCalculated(false){
}

void BallSymbols::registerSymbols(Xabsl2Engine& engine)
{
  #define regDoubleFct( name, object) \
    engine.registerDecimalInputSymbol( name ,this, \
    (double (Xabsl2FunctionProvider::*)()) object );
  #define regDoubleSym( name, object) \
    engine.registerDecimalInputSymbol( name , object );
  #define regBoolFct( name, object) \
    engine.registerBooleanInputSymbol( name ,this, \
    (bool (Xabsl2FunctionProvider::*)()) object );
  #define regBoolSym( name, object) \
    engine.registerBooleanInputSymbol( name , object );
  #define regEnumOutSymbol( name, object) \
    engine.registerEnumeratedOutputSymbol( name , object );
  #define regEnumOutSymbolElement( nameObject , nameEnum , number ) \
    engine.registerEnumeratedOutputSymbolEnumElement( nameObject ,  nameEnum , number);

  //Bool's:
  regBoolFct("ball.ball-can-be-intercepted", &BallSymbols::getBallCanBeIntercepted);
  regBoolSym("ball.ball-was-seen", &ballModel.ballWasSeen);
  regBoolFct("ball.just-seen", &BallSymbols::getJustSeen);
  regBoolSym("ball.play-ball-precisely", &playBallPrecisely);
  regBoolSym("ball.rolls-by-left", &(ballModel.seen.ballRollsByLeft));
  regBoolSym("ball.rolls-by-right", &(ballModel.seen.ballRollsByRight));
  regBoolSym("ball.rolls-far-by-left", &(ballModel.seen.ballRollsFarByLeft));
  regBoolSym("ball.rolls-far-by-right", &(ballModel.seen.ballRollsFarByRight));
  regBoolSym("ball.rolls-fast", &(ballModel.seen.ballRollsFast));
  regBoolSym("ball.rolls-towards-robot", &(ballModel.seen.ballRollsTowardsRobot));
  regBoolFct("ball.seen.ball-in-front-of-opponent-goal", &BallSymbols::getBallSeenInFrontOfOpponentGoal);
  
  //Double's:
  regDoubleFct("ball.angle-to-opponent-goal", &BallSymbols::getAngleToOpponentGoal);
  regDoubleSym("ball.average-distance", &averageDistance);
  regDoubleFct("ball.consecutively-seen-time", &BallSymbols::getConsecutivelySeenTime);
  regDoubleFct("ball.distance-to-use-seen-max", &BallSymbols::getMaxDistanceToUseSeen);
  regDoubleFct("ball.hypothetical.angle", &BallSymbols::getHypotheticalAngle);
  regDoubleFct("ball.hypothetical.distance", &BallSymbols::getHypotheticalDistance);  
  regDoubleSym("ball.hypothetical.x", &(ballModel.hypothetical.positionField.x));
  regDoubleSym("ball.hypothetical.y",&(ballModel.hypothetical.positionField.y));
  regDoubleFct("ball.interception-point.x", &BallSymbols::getBallInterceptionPointX);
  regDoubleFct("ball.interception-point.y", &BallSymbols::getBallInterceptionPointY);
  regDoubleFct("ball.just-seen", &BallSymbols::getJustSeen);
  regDoubleFct("ball.known-or-near-relative-speed.x", &BallSymbols::getKnownOrNearRelativeSpeedX);
  regDoubleFct("ball.known-or-near-relative-speed.y", &BallSymbols::getKnownOrNearRelativeSpeedY);
  regDoubleFct("ball.known-or-near-speed.x", &BallSymbols::getKnownOrNearSpeedX);
  regDoubleFct("ball.known-or-near-speed.y", &BallSymbols::getKnownOrNearRelativeSpeedY);
  regDoubleFct("ball.known-or-near-speed", &BallSymbols::getKnownOrNearSpeedAbs);
  regDoubleFct("ball.known-or-near.angle-to-own-goal", &BallSymbols::getKnownOrNearAngleToOwnGoal);
  regDoubleFct("ball.known-or-near.angle", &BallSymbols::getKnownOrNearAngle);
  regDoubleFct("ball.known-or-near.distance-to-own-penalty-area", &BallSymbols::getKnownOrNearDistanceToOwnPenaltyArea);
  regDoubleFct("ball.known-or-near.distance", &BallSymbols::getKnownOrNearDistance);
  regDoubleFct("ball.known-or-near.probability", &BallSymbols::getKnownOrNearProbability);
  regDoubleFct("ball.known-or-near.relative-x", &BallSymbols::getKnownOrNearRelativeX);
  regDoubleFct("ball.known-or-near.relative-y", &BallSymbols::getKnownOrNearRelativeY);
  regDoubleFct("ball.known-or-near.x", &BallSymbols::getKnownOrNearX);
  regDoubleFct("ball.known-or-near.y", &BallSymbols::getKnownOrNearY);
  regDoubleFct("ball.known.angle", &BallSymbols::getKnownAngle);
  regDoubleFct("ball.known.distance", &BallSymbols::getKnownDistance);
  regDoubleFct("ball.known.x", &BallSymbols::getKnownX);
  regDoubleFct("ball.known.y", &BallSymbols::getKnownY);
  regDoubleFct("ball.number-of-images-with-ball-percept", &BallSymbols::getNumberOfImagesWithBallPercept);
  regDoubleFct("ball.number-of-images-without-ball-percept", &BallSymbols::getNumberOfImagesWithoutBallPercept);
  regDoubleFct("ball.positionValidity", &BallSymbols::getPositionValidity);
  regDoubleFct("ball.projected-distance-on-y-axis", &BallSymbols::getProjectedDistanceOnYAxis);
  regDoubleFct("ball.propagated.angle", &BallSymbols::getPropagatedAngle);
  regDoubleFct("ball.propagated.distance", &BallSymbols::getPropagatedDistance);
  regDoubleFct("ball.propagated.position.probability", &BallSymbols::getPropagatedPositionValidity);
  regDoubleFct("ball.propagated.relative-speed.x", &BallSymbols::getPropagatedRelativeSpeedX);
  regDoubleFct("ball.propagated.relative-speed.y", &BallSymbols::getPropagatedRelativeSpeedY);
  regDoubleFct("ball.propagated.relative-x", &BallSymbols::getPropagatedRelativeX);
  regDoubleFct("ball.propagated.relative-y", &BallSymbols::getPropagatedRelativeY);
  regDoubleFct("ball.propagated.speed.probability", &BallSymbols::getPropagatedVelocityValidity);
  regDoubleFct("ball.propagated.speed.x", &BallSymbols::getPropagatedSpeedX);
  regDoubleFct("ball.propagated.speed.y", &BallSymbols::getPropagatedSpeedY);
  regDoubleFct("ball.propagated.x", &BallSymbols::getPropagatedX);
  regDoubleFct("ball.propagated.y", &BallSymbols::getPropagatedY);
  regDoubleFct("ball.seen.angle", &BallSymbols::getSeenAngle);
  regDoubleFct("ball.seen.distance-to-border", &BallSymbols::getSeenDistanceToBorder);
  regDoubleFct("ball.seen.distance-to-own-penalty-area", &BallSymbols::getDistanceSeenBallToOwnPenaltyArea);
  regDoubleFct("ball.seen.distance-x", &BallSymbols::getSeenDistanceX);
  regDoubleFct("ball.seen.distance-y", &BallSymbols::getSeenDistanceY);
  regDoubleFct("ball.seen.distance", &BallSymbols::getSeenDistance);
  regDoubleFct("ball.seen.position.probability", &BallSymbols::getSeenPositionValidity);
  regDoubleFct("ball.seen.relative-speed.x", &BallSymbols::getSeenRelativeSpeedX);
  regDoubleFct("ball.seen.relative-speed.y", &BallSymbols::getSeenRelativeSpeedY);
  regDoubleFct("ball.seen.relative-x", &BallSymbols::getSeenRelativeX);
  regDoubleFct("ball.seen.relative-y", &BallSymbols::getSeenRelativeY);
  regDoubleFct("ball.seen.speed.probability", &BallSymbols::getSeenVelocityValidity);
  regDoubleFct("ball.seen.speed.x", &BallSymbols::getSeenSpeedX);
  regDoubleFct("ball.seen.speed.y", &BallSymbols::getSeenSpeedY);
  regDoubleFct("ball.seen.speed", &BallSymbols::getSeenSpeed);
  regDoubleSym("ball.seen.x", &(ballModel.seen.positionField.x));
  regDoubleSym("ball.seen.y", &(ballModel.seen.positionField.y));
  regDoubleFct("ball.speedValidity", &BallSymbols::getSpeedValidity);
  regDoubleFct("ball.time-after-which-communicated-balls-are-accepted", &BallSymbols::getTimeAfterWhichCommunicatedBallAreAccepted);
  regDoubleFct("ball.time-after-which-propagated-are-used", &BallSymbols::getTimeAfterWhichPropagatedAreUsed);
  regDoubleFct("ball.time-since-last-known", &BallSymbols::getTimeSinceLastKnown);
  regDoubleFct("ball.time-since-last-seen-consecutively", &BallSymbols::getTimeSinceLastSeenConsecutively);
  regDoubleFct("ball.time-since-last-seen", &BallSymbols::getTimeSinceLastSeen);
  regDoubleFct("ball.time-until-ball-crosses-y-axis", &BallSymbols::getTimeUntilBallCrossesYAxis);

  //Enum's:
  regEnumOutSymbol("ball.precision", &ballPrecision);
  regEnumOutSymbolElement("ball.precision", "precision.penalty-shooter", 1);
  regEnumOutSymbolElement("ball.precision", "precision.player", 0);

  #undef regDoubleFct
  #undef regDoubleSym
  #undef regBoolFct
  #undef regBoolSym
  #undef regEnumOutSymbol
  #undef regEnumOutSymbolElement
}

void BallSymbols::update()
{
  ballDistanceRingBuffer.add(
    (int)Geometry::distanceTo(robotPose.getPose(), ballModel.seen.positionField) );
  
  if(ballDistanceRingBuffer.getNumberOfEntries() != 0)
  {
    averageDistance = ballDistanceRingBuffer.getSum() / ballDistanceRingBuffer.getNumberOfEntries();
  }
  else averageDistance = 1000;

  NDECLARE_DEBUGDRAWING("behavior:symbols:averageDistanceToBall", "drawingOnField", "an orange bar shows the average distance to the ball");
  Pose2D leftPoint = robotPose + Vector2<double>(averageDistance, 500);
  Pose2D rightPoint = robotPose + Vector2<double>(averageDistance, -500);
  NCIRCLE("behavior:symbols:averageDistanceToBall",
    (int)robotPose.translation.x, (int)robotPose.translation.y, averageDistance,
    50, Drawings::ps_dot, Drawings::orange);
    
  playBallPrecisely = (ballPrecision == 0 ? false : true);

  interceptionAlreadyCalculated = false;
  ballCanBeIntercepted = false;
}


double BallSymbols::getKnownDistance()
{
  return ballModel.getKnownBallState().positionRobot.abs();  
}

double BallSymbols::getSeenDistance()
{
  return ballModel.seen.positionRobot.abs();
}

double BallSymbols::getSeenDistanceX()
{
  return ballModel.seen.positionRobot.x;
}

double BallSymbols::getSeenDistanceY()
{
  return ballModel.seen.positionRobot.y;
}

double BallSymbols::getKnownAngle()
{
  return toDegrees(
   Geometry::angleTo(robotPose.getPose(),
                     ballModel.getKnownPosition(
                        BallModel::behaviorControlTimeAfterWhichCommunicatedBallsAreAccepted)));
}

double BallSymbols::getTimeAfterWhichCommunicatedBallAreAccepted()
{
  return (double)BallModel::behaviorControlTimeAfterWhichCommunicatedBallsAreAccepted;
}

double BallSymbols::getSeenAngle()
{
  return toDegrees(Geometry::angleTo(robotPose.getPose(),
    ballModel.seen.positionField));
}

double BallSymbols::getSeenSpeed()
{
  return ballModel.seen.speedField.abs();
}

double BallSymbols::getSeenRelativeSpeedX()
{
  return ballModel.seen.speedRobot.x;
}

double BallSymbols::getSeenRelativeSpeedY()
{
  return ballModel.seen.speedRobot.y;
}

double BallSymbols::getDistanceSeenBallToOwnPenaltyArea()
{
  return FieldDimensions::distanceToOwnPenaltyArea(ballModel.seen.positionField);
}

double BallSymbols::getTimeUntilBallCrossesYAxis()
{
  return (double)ballModel.seen.timeTillBallCrossesYAxis;
}

double BallSymbols::getProjectedDistanceOnYAxis()
{
  return ballModel.seen.projectedDistanceOnYAxis;
}

double BallSymbols::getKnownX()
{
  return ballModel.getKnownPosition(
    BallModel::behaviorControlTimeAfterWhichCommunicatedBallsAreAccepted).x;
}

double BallSymbols::getKnownY()
{
  return ballModel.getKnownPosition(
    BallModel::behaviorControlTimeAfterWhichCommunicatedBallsAreAccepted).y;
}

double BallSymbols::getHypotheticalDistance()
{
  return ballModel.hypothetical.positionRobot.abs();
}

double BallSymbols::getHypotheticalAngle()
{
  return toDegrees(Geometry::angleTo(robotPose.getPose(),
    ballModel.hypothetical.positionField) + robotPose.rotation);
}

double BallSymbols::getPositionValidity()
{
  return ballModel.seen.getPositionValidity();
}

double BallSymbols::getSpeedValidity()
{
  return ballModel.seen.getSpeedValidity();
}

double BallSymbols::getTimeSinceLastKnown()
{
  return ballModel.getTimeSinceLastKnown(
    BallModel::behaviorControlTimeAfterWhichCommunicatedBallsAreAccepted);
}

double BallSymbols::getTimeSinceLastSeen()
{
  return SystemCall::getTimeSince(ballModel.seen.timeWhenLastSeen);
}

double BallSymbols::getConsecutivelySeenTime()
{
  return ballModel.seen.timeUntilSeenConsecutively 
    - ballModel.seen.timeWhenFirstSeenConsecutively;
}

double BallSymbols::getTimeSinceLastSeenConsecutively()
{
  return SystemCall::getTimeSince(ballModel.seen.timeUntilSeenConsecutively);
}

bool BallSymbols::getBallSeenInFrontOfOpponentGoal(){
  //return ballModel.seen.ballInFrontOfOpponentGoal;
  return ballModel.getKnownBallState().ballInFrontOfOpponentGoal;
}

bool BallSymbols::getJustSeen()
{
  return SystemCall::getTimeSince(ballModel.seen.timeWhenLastSeen) < 150;
}

double BallSymbols::getAngleToOpponentGoal()
{
  //return toDegrees(normalize(Geometry::angleTo(ballModel.seen.positionField,
  //                                             Vector2<double>(xPosOpponentGroundline,
  //                                                             yPosCenterGoal))));
  return toDegrees(normalize(Geometry::angleTo(ballModel.getKnownBallState().positionField,
                                               Vector2<double>(xPosOpponentGroundline,
                                                               yPosCenterGoal))));
}

double BallSymbols::getSeenDistanceToBorder()
{
  return FieldDimensions::distanceToBorder(ballModel.seen.positionField);
}

double BallSymbols::getNumberOfImagesWithBallPercept()
{
  return ballModel.numberOfImagesWithBallPercept;
}

double BallSymbols::getNumberOfImagesWithoutBallPercept()
{
  return ballModel.numberOfImagesWithoutBallPercept;
}

double BallSymbols::getSeenPositionValidity()
{
  return ballModel.seen.positionProb;
  //return ballModel.getKnownBallState().positionProb;
}

double BallSymbols::getSeenVelocityValidity()
{
  return ballModel.seen.velocityProb;
  //return ballModel.getKnownBallState().velocityProb;
}

double BallSymbols::getPropagatedPositionValidity()
{
  return ballModel.propagated.positionProb;
}

double BallSymbols::getPropagatedVelocityValidity()
{
  return ballModel.propagated.velocityProb;
}

double BallSymbols::getPropagatedAngle()
{
  return toDegrees(Geometry::angleTo(robotPose.getPose(),
                                     ballModel.propagated.positionField));
}

double BallSymbols::getPropagatedDistance()
{
  return ballModel.propagated.positionRobot.abs();  
}

double BallSymbols::getPropagatedX()
{
  return ballModel.propagated.positionField.x;
}

double BallSymbols::getPropagatedY()
{
  return ballModel.propagated.positionField.y;
}

double BallSymbols::getTimeAfterWhichPropagatedAreUsed()
{
  return BallModel::timeAfterWhichPropagatedAreUsed;
}

double BallSymbols::getMaxDistanceToUseSeen()
{
  return BallModel::maxDistanceToUseSeen;
}

double BallSymbols::getPropagatedSpeedX()
{
  return ballModel.propagated.speedField.x;
}

double BallSymbols::getPropagatedSpeedY()
{
  return ballModel.propagated.speedField.y;
}

double BallSymbols::getPropagatedRelativeX()
{
  return ballModel.propagated.positionRobot.x;
}

double BallSymbols::getPropagatedRelativeY()
{
  return ballModel.propagated.positionRobot.y;
}

double BallSymbols::getPropagatedRelativeSpeedX()
{
  return ballModel.propagated.speedRobot.x;
}

double BallSymbols::getPropagatedRelativeSpeedY()
{
  return ballModel.propagated.speedRobot.y;
}

double BallSymbols::getSeenSpeedX()
{
  return ballModel.seen.speedField.x;
  //return ballModel.getKnownBallState().speedField.x;
}

double BallSymbols::getSeenSpeedY()
{
  return ballModel.seen.speedField.y;
  //return ballModel.getKnownBallState().speedField.y;
}

double BallSymbols::getKnownOrNearDistance()
{
  return ballModel.getKnownBallState().positionRobot.abs();
  //return ballModel.getKnownPosition(
  //  BallModel::behaviorControlTimeAfterWhichCommunicatedBallsAreAccepted,
  //  BallModel::timeAfterWhichPropagatedAreUsed,
  //  BallModel::maxDistanceToUseSeen).abs();
}


double BallSymbols::getKnownOrNearAngle()
{
  return toDegrees(
    Geometry::angleTo(robotPose.getPose(),
                      ballModel.getKnownPosition(
                        BallModel::behaviorControlTimeAfterWhichCommunicatedBallsAreAccepted,
                        BallModel::timeAfterWhichPropagatedAreUsed,
                        BallModel::maxDistanceToUseSeen,
                        BallModel::minDistanceToUseSeen)));
}

double BallSymbols::getKnownOrNearX()
{
  return ballModel.getKnownPosition(
    BallModel::behaviorControlTimeAfterWhichCommunicatedBallsAreAccepted,
    BallModel::timeAfterWhichPropagatedAreUsed,
    BallModel::maxDistanceToUseSeen,
    BallModel::minDistanceToUseSeen).x;
}

double BallSymbols::getKnownOrNearProbability()
{
  return ballModel.getKnownBallState(
    BallModel::behaviorControlTimeAfterWhichCommunicatedBallsAreAccepted,
    BallModel::timeAfterWhichPropagatedAreUsed,
    BallModel::maxDistanceToUseSeen,
    BallModel::minDistanceToUseSeen).positionProb;
}

double BallSymbols::getKnownOrNearY()
{
  return ballModel.getKnownPosition(
    BallModel::behaviorControlTimeAfterWhichCommunicatedBallsAreAccepted,
    BallModel::timeAfterWhichPropagatedAreUsed,
    BallModel::maxDistanceToUseSeen,
    BallModel::minDistanceToUseSeen).y;
}

double BallSymbols::getKnownOrNearRelativeX()
{
  return ballModel.getKnownBallState(
    BallModel::behaviorControlTimeAfterWhichCommunicatedBallsAreAccepted,
    BallModel::timeAfterWhichPropagatedAreUsed,
    BallModel::maxDistanceToUseSeen,
    BallModel::minDistanceToUseSeen).positionRobot.x;
}

double BallSymbols::getKnownOrNearRelativeY()
{
  return ballModel.getKnownBallState(
    BallModel::behaviorControlTimeAfterWhichCommunicatedBallsAreAccepted,
    BallModel::timeAfterWhichPropagatedAreUsed,
    BallModel::maxDistanceToUseSeen,
    BallModel::minDistanceToUseSeen).positionRobot.y;
}

double BallSymbols::getKnownOrNearSpeedX()
{
  return ballModel.getKnownBallState().speedField.x;
}

double BallSymbols::getKnownOrNearSpeedY()
{
  return ballModel.getKnownBallState().speedField.y;
}

double BallSymbols::getKnownOrNearRelativeSpeedX()
{
  return ballModel.getKnownBallState().speedRobot.x;
}

double BallSymbols::getKnownOrNearRelativeSpeedY()
{
  return ballModel.getKnownBallState().speedRobot.y;
}

double BallSymbols::getKnownOrNearSpeedAbs()
{
  Vector2<double> speed(ballModel.getKnownBallState().speedField.x,
    ballModel.getKnownBallState().speedField.y);
  return speed.abs();
}

double BallSymbols::getSeenRelativeX()
{
  return ballModel.seen.positionRobot.x;
  //return ballModel.getKnownBallState().positionRobot.x;
}

double BallSymbols::getSeenRelativeY()
{
  return ballModel.seen.positionRobot.y;
  //return ballModel.getKnownBallState().positionRobot.y;
}

double BallSymbols::getKnownOrNearAngleToOwnGoal()
{
  Pose2D goalpoint(0, xPosOwnGroundline, 0);
  return toDegrees(Geometry::angleTo(goalpoint, ballModel.getKnownBallState().positionField));
}

double BallSymbols::getKnownOrNearDistanceToOwnPenaltyArea()
{
  return FieldDimensions::distanceToOwnPenaltyArea(ballModel.getKnownBallState().positionField);
}

double BallSymbols::getBallInterceptionPointX()
{
  if(interceptionAlreadyCalculated)
    return interceptionPoint.x;
  else
    calculateInterceptionPoint();
  return interceptionPoint.x;
}

double BallSymbols::getBallInterceptionPointY()
{
  if(interceptionAlreadyCalculated)
    return interceptionPoint.y;
  else
    calculateInterceptionPoint();
  return interceptionPoint.y;
}

bool BallSymbols::getBallCanBeIntercepted()
{
  if(interceptionAlreadyCalculated)
    return ballCanBeIntercepted;
  else
    calculateInterceptionPoint();
  return ballCanBeIntercepted;
}

void BallSymbols::calculateInterceptionPoint()
{
  Vector2<double> ballPosition = ballModel.getKnownBallState().positionRobot;
  Vector2<double> ballSpeed = ballModel.getKnownBallState().speedRobot;

  //safe distance 300 mm
  /*double safeDistance = 300;
  ballPosition += ballSpeed.normalize() * safeDistance;*/

  double speedRobot = 450;

  double a = sqr(speedRobot) - sqr(ballSpeed.x) - sqr(ballSpeed.y);
  double b = - 2 * (ballPosition.x * ballSpeed.x + ballPosition.y * ballSpeed.y);
  double c = - (sqr(ballPosition.x) + sqr(ballPosition.y));

  double squareRoot = sqrt(sqr(b) - 4 * a * c);
  double t1 = (- b + squareRoot) / (2 * a);
  double t2 = (- b - squareRoot) / (2 * a);

  interceptionAlreadyCalculated = true;

  ballCanBeIntercepted = true;

  double t = 0;
  if((t1 > 0) && (t2 > 0))
    t = min(t1, t2);
  else if((t1 < 0) && (t2 > 0))
    t = t2;
  else if((t2 < 0) && (t1 > 0))
    t = t1;
  else
    ballCanBeIntercepted = false;

  if(ballCanBeIntercepted)
  {
    double l = sqrt(ballSpeed.x * ballSpeed.x + ballSpeed.y * ballSpeed.y);
    double newLength
      = -(GT2005BallLocatorParameters::coefficientOfFriction * 9810 * t) + l;
    double l2 = 0;
    if(l != 0)
      l2 = (1 / l) * newLength;
    Vector2<double> ballSpeedNew = ballSpeed * l2;

    interceptionPoint.x = ballPosition.x + t * ballSpeedNew.x;
    interceptionPoint.y = ballPosition.y + t * ballSpeedNew.y;
  }
  else
  {
    interceptionPoint.x = ballPosition.x;
    interceptionPoint.y = ballPosition.y;
  }
}

---