Modules/BehaviorControl/GT2005BehaviorControl/GT2005Symbols/GT2005StrategySymbols.cpp

Go to the documentation of this file.

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

#include "GT2005StrategySymbols.h"
#include "Tools/FieldDimensions.h"


GT2005StrategySymbols::GT2005StrategySymbols(BehaviorControlInterfaces& interfaces)
: BehaviorControlInterfaces(interfaces),
  ballIsHandledAtTheMoment(false),
  goingToInterceptionPoint(false),
  doProfile(GT2005StrategySymbols::dontDoProfiling), 
  writeProfile(GT2005StrategySymbols::dontWriteProfiles)
{
  role = BehaviorTeamMessage::goalie;
  estimatedTimeToReachBall = 0.0;
  timeSinceLastCarryBall = 0;
  behaviorTimeCarryBallState = dontSave;
  timeSinceLastCarryBallSaved = false;
  timeSinceLastKick = 0;
  behaviorTimeKickState = dontSave;
  timeSinceLastKickSaved = false;
}

void GT2005StrategySymbols::registerSymbols(Xabsl2Engine& engine)
{
  // "robot-number"
  engine.registerDecimalInputSymbol("robot-number", this,
    (double(Xabsl2FunctionProvider::*)())&GT2005StrategySymbols::getRobotNumber);
  
  // "role"
  engine.registerEnumeratedInputSymbol("role", (int *)&role);
  engine.registerEnumeratedInputSymbolEnumElement("role", "goalie", BehaviorTeamMessage::goalie);
  engine.registerEnumeratedInputSymbolEnumElement("role", "striker", BehaviorTeamMessage::striker);
  engine.registerEnumeratedInputSymbolEnumElement("role", "defensive-supporter", BehaviorTeamMessage::defensiveSupporter);
  engine.registerEnumeratedInputSymbolEnumElement("role", "offensive-supporter", BehaviorTeamMessage::offensiveSupporter);
  
  // "estimated-time-to-reach-ball"
  engine.registerDecimalInputSymbol("estimated-time-to-reach-ball", (double *)&estimatedTimeToReachBall);
  
  // "sent-game-state"
  engine.registerEnumeratedOutputSymbol("sent-game-state",(int*)&outgoingBehaviorTeamMessage.gameState);
  engine.registerEnumeratedOutputSymbolEnumElement("sent-game-state","sent-game-state.sleep",BehaviorTeamMessage::sleep);
  engine.registerEnumeratedOutputSymbolEnumElement("sent-game-state","sent-game-state.initial",BehaviorTeamMessage::initial);
  engine.registerEnumeratedOutputSymbolEnumElement("sent-game-state","sent-game-state.ready",BehaviorTeamMessage::ready);
  engine.registerEnumeratedOutputSymbolEnumElement("sent-game-state","sent-game-state.playing",BehaviorTeamMessage::playing);
  engine.registerEnumeratedOutputSymbolEnumElement("sent-game-state","sent-game-state.penalized",BehaviorTeamMessage::penalized);
  engine.registerEnumeratedOutputSymbolEnumElement("sent-game-state","sent-game-state.finished",BehaviorTeamMessage::finished);
  engine.registerEnumeratedOutputSymbolEnumElement("sent-game-state","sent-game-state.set",BehaviorTeamMessage::set);
  
  
  // "another-player-is-in-ready-state"
  engine.registerBooleanInputSymbol("another-player-is-in-ready-state",
    this,(bool(Xabsl2FunctionProvider::*)())&GT2005StrategySymbols::getAnotherPlayerIsInReadyState);
  
  // "another-player-is-in-initial-state"
  engine.registerBooleanInputSymbol("another-player-is-in-initial-state",
    this,(bool(Xabsl2FunctionProvider::*)())&GT2005StrategySymbols::getAnotherPlayerIsInInitialState);
  
  // "team-message"
  engine.registerEnumeratedOutputSymbol("team-message",(int*)&outgoingBehaviorTeamMessage.message);
  engine.registerEnumeratedOutputSymbolEnumElement("team-message","team-message.none", BehaviorTeamMessage::none);
  engine.registerEnumeratedOutputSymbolEnumElement("team-message","team-message.performing-a-kick",BehaviorTeamMessage::performingAKick);
  engine.registerEnumeratedOutputSymbolEnumElement("team-message","team-message.performing-a-pass",BehaviorTeamMessage::passing);
  
  // "another-teammate-is-performing-a-kick"
  engine.registerBooleanInputSymbol("another-teammate-is-performing-a-kick",
    this,(bool(Xabsl2FunctionProvider::*)())&GT2005StrategySymbols::getAnotherTeammateIsPerformingAKick);
  
  // "another-teammate-is-performing-a-pass"
  engine.registerBooleanInputSymbol("another-teammate-is-performing-a-pass",
    this,(bool(Xabsl2FunctionProvider::*)())&GT2005StrategySymbols::getAnotherTeammateIsPerformingAPass);
  
  // "the-striker-is-playing-near-the-opponent-goal"
  engine.registerBooleanInputSymbol("the-striker-is-playing-near-the-opponent-goal",
    this,(bool(Xabsl2FunctionProvider::*)())&GT2005StrategySymbols::getTheStrikerIsPlayingNearTheOpponentGoal);
  
  // "the-striker-is-not-playing-near-the-opponent-goal"
  engine.registerBooleanInputSymbol("the-striker-is-not-playing-near-the-opponent-goal",
    this,(bool(Xabsl2FunctionProvider::*)())&GT2005StrategySymbols::getTheStrikerIsNotPlayingNearTheOpponentGoal);
  
  // "the-striker-is-playing-near-the-own-goal"
  engine.registerBooleanInputSymbol("the-striker-is-playing-near-the-own-goal",
    this,(bool(Xabsl2FunctionProvider::*)())&GT2005StrategySymbols::getTheStrikerIsPlayingNearTheOwnGoal);
  
  // "the-striker-is-not-playing-near-the-own-goal"
  engine.registerBooleanInputSymbol("the-striker-is-not-playing-near-the-own-goal",
    this,(bool(Xabsl2FunctionProvider::*)())&GT2005StrategySymbols::getTheStrikerIsNotPlayingNearTheOwnGoal);

  // "goalie-max-position-speed"
  engine.registerDecimalInputSymbol("goalie-max-position-speed", this,
    (double (Xabsl2FunctionProvider::*)())&GT2005StrategySymbols::getGoalieMaxPositionSpeed);
    
  engine.registerDecimalInputSymbol("search-ball.x", this,
    (double (Xabsl2FunctionProvider::*)())&GT2005StrategySymbols::getSearchBallX);
  
  // "get-angle-to-teammate
  engine.registerDecimalInputFunction("get-angle-to-teammate",this,
    (double (Xabsl2FunctionProvider::*)())&GT2005StrategySymbols::getAngleToTeammate);
  engine.registerDecimalInputFunctionParameter("get-angle-to-teammate","get-angle-to-teammate.index",GT2005StrategySymbols::angleToTeammateIndex);

  // strategy.ball-is-handled-at-the-moment
  engine.registerBooleanInputSymbol("strategy.ball-is-handled-at-the-moment", &ballIsHandledAtTheMoment);

  // strategy.going-to-interception-point
  engine.registerBooleanInputSymbol("strategy.going-to-interception-point", &goingToInterceptionPoint);
  
  // strategy.time-since-last-carry-ball
  engine.registerDecimalInputSymbol("strategy.time-since-last-carry-ball", this,
    (double (Xabsl2FunctionProvider::*)())&GT2005StrategySymbols::getTimeSinceLastCarryBall);
  // strategy.set-time-carry-ball
  engine.registerEnumeratedOutputSymbol("strategy.set-time-carry-ball", (int*)&behaviorTimeCarryBallState);
  engine.registerEnumeratedOutputSymbolEnumElement("strategy.set-time-carry-ball","strategy.set-time-carry-ball.dont-save",dontSave);
  engine.registerEnumeratedOutputSymbolEnumElement("strategy.set-time-carry-ball","strategy.set-time-carry-ball.save-time",saveTime);
  engine.registerEnumeratedOutputSymbolEnumElement("strategy.set-time-carry-ball","strategy.set-time-carry-ball.reset-time",resetTime);
  

  // strategy.time-since-last-kick
  engine.registerDecimalInputSymbol("strategy.time-since-last-kick", this,
    (double (Xabsl2FunctionProvider::*)())&GT2005StrategySymbols::getTimeSinceLastKick);
  
  // strategy.set-time-kick
  engine.registerEnumeratedOutputSymbol("strategy.set-time-kick", (int*)&behaviorTimeKickState);
  engine.registerEnumeratedOutputSymbolEnumElement("strategy.set-time-kick","strategy.set-time-kick.dont-save",dontSave);
  engine.registerEnumeratedOutputSymbolEnumElement("strategy.set-time-kick","strategy.set-time-kick.save-time",saveTime);
  engine.registerEnumeratedOutputSymbolEnumElement("strategy.set-time-kick","strategy.set-time-kick.reset-time",resetTime);
  


  // strategy.ball-handling
  engine.registerEnumeratedOutputSymbol("strategy.ball-handling", (int*)&ballHandling.behaviorBallState);
  engine.registerEnumeratedOutputSymbolEnumElement("strategy.ball-handling","going-to-interception-point",BallHandling::goToInterceptionPoint);
  engine.registerEnumeratedOutputSymbolEnumElement("strategy.ball-handling","dribble-the-ball",BallHandling::dribbleTheBall);
  engine.registerEnumeratedOutputSymbolEnumElement("strategy.ball-handling","performing-a-kick",BallHandling::performingAKick);
  engine.registerEnumeratedOutputSymbolEnumElement("strategy.ball-handling","handling-the-ball",BallHandling::handlingTheBall);
  engine.registerEnumeratedOutputSymbolEnumElement("strategy.ball-handling","not-handling-the-ball",BallHandling::notHandlingTheBall);
}

void GT2005StrategySymbols::update()
{
  estimateTimeToReachBall();
  MODIFY("Symbols:GT2005Strategy:estimatedTimeToReachBall", estimatedTimeToReachBall);
  computeRole();
  if ( role != roleLastFrame )
  {
    timeStampSinceRoleChange = SystemCall::getCurrentSystemTime();
  }
  
  roleLastFrame = role;
  outgoingBehaviorTeamMessage.timeSinceRoleChange = SystemCall::getTimeSince(timeStampSinceRoleChange);
  
  outgoingBehaviorTeamMessage.estimatedTimeToReachBall = estimatedTimeToReachBall;
  outgoingBehaviorTeamMessage.dynamicRole = role;

  // use the information that was set by the options in the last frame
  ballIsHandledAtTheMoment = (ballHandling.behaviorBallState == BallHandling::notHandlingTheBall || 
                              ballHandling.behaviorBallState == BallHandling::goToInterceptionPoint) ? false : true;
  goingToInterceptionPoint = ballHandling.behaviorBallState == BallHandling::goToInterceptionPoint;
  
  switch(behaviorTimeCarryBallState)
  {
  case dontSave  : timeSinceLastCarryBallSaved = false; break;
  case saveTime  : if (!timeSinceLastCarryBallSaved) {
          timeSinceLastCarryBall = SystemCall::getCurrentSystemTime(); 
          timeSinceLastCarryBallSaved = true;
           }
           break;
  case resetTime : timeSinceLastCarryBall = 0; timeSinceLastCarryBallSaved = false; break;
  }
  behaviorTimeCarryBallState = dontSave;

  switch(behaviorTimeKickState)
  {
  case dontSave : 
    timeSinceLastKickSaved = false; 
    break;
  case saveTime  : 
    if (!timeSinceLastCarryBallSaved) 
    {
      timeSinceLastKick = SystemCall::getCurrentSystemTime(); 
      timeSinceLastKickSaved = true;
    }
    break;
  case resetTime : 
    timeSinceLastKick = 0; 
    timeSinceLastKickSaved = false; 
    break;
  }
  behaviorTimeKickState = dontSave;

  DEBUG_RESPONSE("Behavior:ballHandling",
    switch (ballHandling.behaviorBallState)
    {
    case BallHandling::notHandlingTheBall: OUTPUT(idText, text, "notHandlingTheBall"); break;
    case BallHandling::dribbleTheBall: OUTPUT(idText, text, "dribbleTheBall"); break;
    case BallHandling::goToInterceptionPoint: OUTPUT(idText, text, "goToInterceptionPoint"); break;
    case BallHandling::handlingTheBall: OUTPUT(idText, text, "handlingTheBall"); break;
    case BallHandling::performingAKick: OUTPUT(idText, text, "performingAKick"); break;
    }
  );
  
  // set "ballWasHandledInLastFrame" to false. It will only become true when
  // an option sets it to true again
  ballHandling.behaviorBallState = BallHandling::notHandlingTheBall;

  NDECLARE_DEBUGDRAWING("behavior:symbols:ball is handled at the moment", "drawingOnField", "shows an orange circle around the robot when true");
  if(ballIsHandledAtTheMoment)
  {
    NCIRCLE("behavior:symbols:ball is handled at the moment", robotPose.translation.x, robotPose.translation.y, 150, 25, Drawings::ps_solid, Drawings::orange);
  }

}

void GT2005StrategySymbols::computeRole()
{
  int i;
  
  if (getPlayer().getPlayerNumber() == Player::one)
  {
    // no role changes for the goalie
    role = BehaviorTeamMessage::goalie;
    return;
  }

  
  // if in the goalzone and ball lies within angle infront, role = striker
  if(FieldDimensions::distanceToOpponentPenaltyArea(robotPose.translation) < 400
    && SystemCall::getTimeSince(ballModel.seen.timeWhenLastSeen) < 1000)
  {
    if(ballModel.seen.ballInFrontOfOpponentGoal)
    {
        role = BehaviorTeamMessage::striker;
        return;
    }
  }
  DEBUG_RESPONSE_NOT("ROLE:disableWLANCheck",
  // fall-back if no wlan
  if (!teamMessageCollection[0].isActual(5000) 
    && !teamMessageCollection[1].isActual(5000)
    && !teamMessageCollection[2].isActual(5000))
  {
    switch(getPlayer().getPlayerNumber())
    {
    case Player::two:
      if (SystemCall::getTimeSince (ballModel.seen.timeWhenLastSeen) > 5000)
        role = BehaviorTeamMessage::defensiveSupporter;
      else if(role == BehaviorTeamMessage::defensiveSupporter)
      { 
        if (ballModel.getKnownBallState().positionField.x < 400)
          role = BehaviorTeamMessage::striker;
        else
          role = BehaviorTeamMessage::defensiveSupporter;
      } else {
        if (ballModel.getKnownBallState().positionField.x < 600)
          role = BehaviorTeamMessage::striker;
        else
          role = BehaviorTeamMessage::defensiveSupporter;
      }
      break;
    case Player::three:
    case Player::four:
      if (SystemCall::getTimeSince (ballModel.seen.timeWhenLastSeen) > 5000)
        role = BehaviorTeamMessage::offensiveSupporter;
      else if (role == BehaviorTeamMessage::offensiveSupporter)
      { 
        if (ballModel.getKnownBallState().positionField.x > -400)
          role = BehaviorTeamMessage::striker;
        else
          role = BehaviorTeamMessage::offensiveSupporter;
      }
      else
      {
        if (ballModel.getKnownBallState().positionField.x > -600)
          role = BehaviorTeamMessage::striker;
        else
          role = BehaviorTeamMessage::offensiveSupporter;
      }
      break;
    }
    return;
  }
  );
  
  // with wlan
  
  // estimate the closest other teammate to the ball
  double minTeammateTime = 100000.0;
  
  unsigned long timeSinceRoleChange = 1000;
  // compute striker bonus
  for (i = 0; i < teamMessageCollection.numberOfTeamMessages; i++ ) 
  {
    if ( teamMessageCollection[i].isActual() ) // only new messages
    {
      if ( teamMessageCollection[i].behaviorTeamMessage.dynamicRole != BehaviorTeamMessage::goalie 
        && teamMessageCollection[i].behaviorTeamMessage.gameState == BehaviorTeamMessage::playing)
        // the robot is not interested in 
        // (1) how fast the goalie can approach the ball 
        // (2) how fast a penalized field player can approach the ball
      {
        if ( teamMessageCollection[i].behaviorTeamMessage.dynamicRole == BehaviorTeamMessage::striker ) 
        {
          timeSinceRoleChange = teamMessageCollection[i].behaviorTeamMessage.timeSinceRoleChange;
        }
      }
    }
  }
  if (role == BehaviorTeamMessage::striker )
  {
    timeSinceRoleChange = outgoingBehaviorTeamMessage.timeSinceRoleChange;
  }

  double strikerbonus = 500.0;

  DEBUG_RESPONSE("behavior:strategy-symbols:timeSinceRoleChange",OUTPUT(idText,text,"ROLE.timeSinceRoleChange = " <<timeSinceRoleChange););
  DEBUG_RESPONSE("behavior:strategy-symbols:dynamic strikerbonus",
  {
    
    double upperBound = 1500;
    double lowerBound = 100;
    double timeBound = 3000;
    MODIFY("behavior:strategy-symbols:upperBound",upperBound);
    MODIFY("behavior:strategy-symbols:lowerBound",lowerBound);
    MODIFY("behavior:strategy-symbols:timeBound",timeBound);
    strikerbonus= -(upperBound-lowerBound)/timeBound 
                * timeSinceRoleChange
                + upperBound;
    if (strikerbonus <lowerBound)
    {
      strikerbonus = lowerBound;
    }
  }
  );
  DEBUG_RESPONSE("behavior:strategy-symbols:strikerbonus",OUTPUT(idText,text,"ROLE.strikerbonus = " <<strikerbonus););
  

  for (i = 0; i < teamMessageCollection.numberOfTeamMessages; i++ ) 
  {
    if ( teamMessageCollection[i].isActual() ) // only new messages
    {
      if ( teamMessageCollection[i].behaviorTeamMessage.dynamicRole != BehaviorTeamMessage::goalie 
        && teamMessageCollection[i].behaviorTeamMessage.gameState == BehaviorTeamMessage::playing)
        // the robot is not interested in 
        // (1) how fast the goalie can approach the ball 
        // (2) how fast a penalized field player can approach the ball
      {
        double time = 
          teamMessageCollection[i].behaviorTeamMessage.estimatedTimeToReachBall;
        
        // bonus for current striker
        if ( teamMessageCollection[i].behaviorTeamMessage.dynamicRole == BehaviorTeamMessage::striker ) 
          time -= strikerbonus;
        
        if (time < minTeammateTime ) 
        {
          minTeammateTime = time;
        }
      }
    }
  }
  
  // bonus for current striker
  if (role == BehaviorTeamMessage::striker)
    minTeammateTime += strikerbonus*2;
  
  // assign striker-role if nearest to the ball
  if ( estimatedTimeToReachBall < minTeammateTime )
  {
    role = BehaviorTeamMessage::striker;
    return;
  }
  
  // assign supporting roles
  double minTeammateX = (double)xPosOpponentGroundline;
  for (i = 0; i < teamMessageCollection.numberOfTeamMessages; i++ ) 
  {
    if ( teamMessageCollection[i].isActual() )
    {
      if ( teamMessageCollection[i].behaviorTeamMessage.dynamicRole != BehaviorTeamMessage::striker 
        && teamMessageCollection[i].behaviorTeamMessage.dynamicRole != BehaviorTeamMessage::goalie 
        && teamMessageCollection[i].behaviorTeamMessage.gameState == BehaviorTeamMessage::playing)
      {
        double teammateX = 
          teamMessageCollection[i].robotPose.translation.x;
        
        // bonus for current offensive supporter
        if ( teamMessageCollection[i].behaviorTeamMessage.dynamicRole == BehaviorTeamMessage::defensiveSupporter ) 
          teammateX -= 300.0;
        
        if (teammateX < minTeammateX ) 
        {
          minTeammateX = teammateX;
        }
      }
    }
  }
  
  // bonus for current offensive supporter
  if ( role == BehaviorTeamMessage::defensiveSupporter ) 
    minTeammateX += 300.0;
  
  if ( robotPose.translation.x <= minTeammateX ) 
    role = BehaviorTeamMessage::defensiveSupporter;
  else
    role = BehaviorTeamMessage::offensiveSupporter;
}

double GT2005StrategySymbols::getGoalieMaxPositionSpeed()
{
  double maxSpeed = 150;
  double minDistance = 300; 

  double minSpeed = 60;
  double maxDistance = 1500;

  double ballDistance = Geometry::distanceTo(robotPose.getPose(),ballModel.seen.positionField);

  double speed = maxSpeed - ((ballDistance - minDistance) * maxSpeed) / (maxDistance ) ;

  speed = max(minSpeed, speed);
  speed = min(maxSpeed, speed);

  return speed;
}

void GT2005StrategySymbols::estimateTimeToReachBall()
{
  //if (ballWasHandledInLastFrame)
  if (ballHandling.behaviorBallState != BallHandling::notHandlingTheBall &&
      ballHandling.behaviorBallState != BallHandling::goToInterceptionPoint)
  {  
    // currently at the ball
    estimatedTimeToReachBall = 0;
    return;
  }

  // no ball known
  if ( ballModel.getTimeSinceLastKnown(BallModel::behaviorControlTimeAfterWhichCommunicatedBallsAreAccepted)
       > 1500 )
  {
    estimatedTimeToReachBall = 10000 + getPlayer().getPlayerNumber();
    return;
  }
 
  Vector2<double> ballPositionToUse = ballModel.seen.positionField;

  DEBUG_RESPONSE("behavior:strategy-symbols:estimate time with known ball",
  {
    ballPositionToUse = ballModel.getKnownPosition(
      BallModel::behaviorControlTimeAfterWhichCommunicatedBallsAreAccepted,
      BallModel::timeAfterWhichPropagatedAreUsed,
      BallModel::maxDistanceToUseSeen,
      BallModel::minDistanceToUseSeen);
  });
 
  // account for distance to ball
  estimatedTimeToReachBall = Geometry::distanceTo(robotPose.translation, ballPositionToUse) / 0.2;
  
  // account if the robot is between the ball and the opponent goal
  
  // the position of the robot
  Vector2<double> robotPosition = robotPose.translation;
  double angleToLeftOpponentGoalPost = Geometry::angleTo(robotPosition, Vector2<double>(xPosOpponentGroundline,yPosLeftGoal));
  double angleToRightOpponentGoalPost = Geometry::angleTo(robotPosition, Vector2<double>(xPosOpponentGroundline,yPosRightGoal));
  if(angleToLeftOpponentGoalPost < angleToRightOpponentGoalPost)
  {
    angleToLeftOpponentGoalPost += pi2;
  }
  double angleToOpponentGoal= (angleToLeftOpponentGoalPost + angleToRightOpponentGoalPost) / 2.0;
  double absoluteAngleToBall = Geometry::angleTo(robotPosition,ballPositionToUse);
  double angleBetweenBallAndOpponentGoal = normalize(angleToOpponentGoal - absoluteAngleToBall);
  
  estimatedTimeToReachBall += 400.0 * fabs(angleBetweenBallAndOpponentGoal);
  
  // longer if ball not seen
  estimatedTimeToReachBall += 2.0 * SystemCall::getTimeSince(ballModel.seen.timeWhenLastSeen);
  
  // test for obstacles
  /*
  if ( isOpponentBetweenRobotAndBall(robotPose) || 
  isOwnBetweenRobotAndBall (robotPose) )
  time += 5000.0;
  */
  
}

double GT2005StrategySymbols::getAngleToTeammate()
{
  
  //OUTPUT(idText, text,"::nrofownplayer:"<<playerPoseCollection.numberOfOwnPlayers);
  
  
  if(1 <= playerPoseCollection.numberOfOwnPlayers)
  {
    return toDegrees(Geometry::angleTo(robotPose, playerPoseCollection.getOwnPlayerPose((int)angleToTeammateIndex).getPose().translation));
  }
  else
  {
    return toDegrees(Geometry::angleTo(robotPose,
      Vector2<double>(xPosOpponentGroundline,yPosCenterGoal)));
  }
}

double GT2005StrategySymbols::getTimeSinceLastCarryBall()
{
  if (timeSinceLastCarryBall > 1)  
    return (double) SystemCall::getTimeSince(timeSinceLastCarryBall);
  else return 99999.0; /* 99 secs since last using should be long enough for behaviour control */
}

double GT2005StrategySymbols::getTimeSinceLastKick()
{
  if (timeSinceLastKick > 1)  
    return (double) SystemCall::getTimeSince(timeSinceLastKick);
  else return 99999.0; /* 99 secs since last using should be long enough for behaviour control */
}

bool GT2005StrategySymbols::getAnotherPlayerIsInReadyState()
{
  for (int i=0; i<3;i++)
  {
    if (teamMessageCollection[i].isActual())
    {
      if (teamMessageCollection[i].behaviorTeamMessage.gameState 
        == BehaviorTeamMessage::ready)
      {
        return true;
      }
    }
  }
  return false;
}

bool GT2005StrategySymbols::getAnotherPlayerIsInInitialState()
{
  for (int i=0; i<3;i++)
  {
    if (teamMessageCollection[i].isActual())
    {
      if (teamMessageCollection[i].behaviorTeamMessage.gameState 
        == BehaviorTeamMessage::initial)
      {
        return true;
      }
    }
  }
  return false;
}

bool GT2005StrategySymbols::getAnotherTeammateIsPerformingAKick()
{
  for (int i=0; i<3;i++)
  {
    if (teamMessageCollection[i].isActual())
    {
      if (teamMessageCollection[i].behaviorTeamMessage.message
        == BehaviorTeamMessage::performingAKick)
      {
        return true;
      }
    }
  }
  return false;
}

bool GT2005StrategySymbols::getAnotherTeammateIsPerformingAPass()
{
  for (int i=0; i<3;i++)
  {
    if (teamMessageCollection[i].isActual())
    {
      if (teamMessageCollection[i].behaviorTeamMessage.message
        == BehaviorTeamMessage::passing)
      {
        return true;
      }
    }
  }
  return false;
}

bool GT2005StrategySymbols::getTheStrikerIsPlayingNearTheOpponentGoal()
{
  for (int i=0; i<3;i++)
  {
    if (teamMessageCollection[i].isActual())
    {
      if (teamMessageCollection[i].behaviorTeamMessage.dynamicRole == BehaviorTeamMessage::striker
        && teamMessageCollection[i].robotPose.translation.x > 1500)
      {
        return true;
      }
    }
  }
  return false;
}

bool GT2005StrategySymbols::getTheStrikerIsNotPlayingNearTheOpponentGoal()
{
  for (int i=0; i<3;i++)
  {
    if (teamMessageCollection[i].isActual())
    {
      if (teamMessageCollection[i].behaviorTeamMessage.dynamicRole == BehaviorTeamMessage::striker
        && teamMessageCollection[i].robotPose.translation.x < 1300)
      {
        return true;
      }
    }
  }
  return false;
}

bool GT2005StrategySymbols::getTheStrikerIsPlayingNearTheOwnGoal()
{
  for (int i=0; i<3;i++)
  {
    if (teamMessageCollection[i].isActual())
    {
      if (teamMessageCollection[i].behaviorTeamMessage.dynamicRole == BehaviorTeamMessage::striker
        && teamMessageCollection[i].robotPose.translation.x < -1200)
      {
        return true;
      }
    }
  }
  return false;
}

bool GT2005StrategySymbols::getTheStrikerIsNotPlayingNearTheOwnGoal()
{
  for (int i=0; i<3;i++)
  {
    if (teamMessageCollection[i].isActual())
    {
      if (teamMessageCollection[i].behaviorTeamMessage.dynamicRole == BehaviorTeamMessage::striker
        && teamMessageCollection[i].robotPose.translation.x > -1000)
      {
        return true;
      }
    }
  }
  return false;
}

double GT2005StrategySymbols::getSearchBallX()
{
  // fall-back if no wlan
  if (!teamMessageCollection[0].isActual(5000) 
    && !teamMessageCollection[1].isActual(5000)
    && !teamMessageCollection[2].isActual(5000))
  {
    switch(getPlayer().getPlayerNumber())
    {
    case Player::two:
      return -1000;
    case Player::three:
      return 0;
    case Player::four:
    default:
      return 1000;
    }
  }
  else
  {
    switch (role)
    {
    case BehaviorTeamMessage::defensiveSupporter:
      return -1000;
    case BehaviorTeamMessage::offensiveSupporter:
      return 1000;
    case BehaviorTeamMessage::striker:
    default:
      return 0;
    }
  }
}

---