complextricks.cc

该文件是包含了机器人足球比赛中的整个系统的代码

  currentTrick->Continue();
  utils.Head_PanForBall(false,lookRight,50);
  return 1;
}
char* ComplexTricks::PostChaseSearchForBall::GetErrorMsg(int c) {
  if (c == 0) return "FOUND_BALL";
  else if (c == 1) return "SEARCHING";
  else if (c == -1) return "BALL_NOT_FOUND";
  return "PKSFB: Unknown message";
}
char* ComplexTricks::PostChaseSearchForBall::GetName() {
  return "PostChaseSearchForBall";
}

ComplexTricks::ChaseWithKick::ChaseWithKick() {
  cout << "ChaseWithKick is DEPRECATED !! Do not use. " << endl << flush;
  currentTrick = new BasicTricks::NullBody();
  headTrick = new BasicTricks::NullHead();
  justKicked = false;
  interruptible = true;
}

ComplexTricks::ChaseWithKick::~ChaseWithKick() {
  delete currentTrick;
  delete headTrick;
}
int ComplexTricks::ChaseWithKick::Start() {
  return Continue();
}
int ComplexTricks::ChaseWithKick::Abort() {
  currentTrick->Abort();
  headTrick->Abort();
  return 0;
}
int ComplexTricks::ChaseWithKick::Continue() {
  headTrick->Continue();

  int cC = currentTrick->Continue();
  char* cMsg = currentTrick->GetErrorMsg(cC);

  if (cC < 1) {
    delete currentTrick;
    if (strcmp(cMsg,"BALL_UNDER_CHIN") == 0) {
      // if kicking off, don't turn !!
      if (frame_-lastReadyFrame_ <= 75) {
        currentTrick = ks.FastSelecta(wo_self_->x_, wo_self_->y_, wo_self_->heading_);
      } else {
        currentTrick = ks.NormalSelecta(wo_self_->x_, wo_self_->y_, wo_self_->heading_);
      }
      interruptible = false;
      justKicked = true;
    } else if (vo_ball_ != NULL) {
      interruptible = true;
      currentTrick = new MovementTricks::ChaseBall();
    } else if (strcmp(cMsg,"NO_BALL_AFTER_KICK") == 0) {
      interruptible = true;
// FIXME this trick has been removed for good.
//    currentTrick = new HeadTricks::HeadCloseSearchForBall(5);
    } else {
      interruptible = true;
      currentTrick = new BasicTricks::NullBody();
      currentTrick->Start();
      return 0;
    }
    currentTrick->Start();
  } else if (strcmp(cMsg,"GRAB_FAIL") == 0) {
    // if grab failed, we want to totally abort.
    // this generally means that a WaitForGrab ended and we could still see the ball (!!)
      cout << "ChaseWithKick: Failed grab." << endl << flush;
      currentTrick->Abort();
      interruptible = true;
      delete currentTrick;
      currentTrick = new MovementTricks::ChaseBall();
      currentTrick->Start();
  }
  // if we've just lost the ball (CLOSE_SEARCH), we're not interruptible for this frame!
  if (interruptible && (strcmp(cMsg,"CLOSE_SEARCH")!=0) ) return 1;
  return 2;
}
bool ComplexTricks::ChaseWithKick::IsUsingHead() {
  return true;
}
char* ComplexTricks::ChaseWithKick::GetErrorMsg(int c) {
  if (c == 0) return "CWK_DONE";
  else if (c == 1) return "INTERRUPTIBLE";
  else if (c == 2) return "NOT_INTERRUPTIBLE";
  return "CWK:NO_MESSAGE";
}
char* ComplexTricks::ChaseWithKick::GetName() {
  return "ChaseWithKick";
}
// END ChaseWithkick
//////////////////////////////////////////////////////////////////////
// BEGIN ComplexKick

//Worst documentation ever!!

//ComplexKick will turn the specified 'normal' amount (first parameter). If it sees the goal
//  at any angle up to its 'maximum' amount (second parameter), it'll try to line it up.
//Notice that if the first two parameters are both 0.0, we need not do a turn at all.

//Once all turning has been completed, we make a kick decision by calling FastSelecta.
//  FastSelecta can only do kicks- it's not allowed to turn. The idea is, we delay the
//  actual kick decision for as long as possible.

//A handy side effect is that all kick decisions are back in KickSelecta now.

ComplexTricks::ComplexKick::ComplexKick(double _normalTurnAmount, double _maxTurnAmount, double _extraFastTurn) {
  currentTrick = NULL;
  turnTrick = NULL;
  // we aren't meant to do a turn. so don't. just choose a kick and start doing it.
  if (_normalTurnAmount == 0.0 && _maxTurnAmount == 0.0) {
    KickSelecta ks;
    currentTrick = ks.FastSelecta(wo_self_->x_, wo_self_->y_, wo_self_->heading_);
  // go the turn !
  } else {
    //currentTrick = new BallTricks::TurnWithBallUntilGoal(_normalTurnAmount,_maxTurnAmount);
    if (ABS(_extraFastTurn) > 65) {
      currentTrick = new BasicTricks::MultiTrick(4, new BasicTricks::Kick(LocomotionCommand::TP_GRAB), new BallTricks::WaitForKick(), new BallTricks::TurnWithBallHeadDown(_extraFastTurn), new BallTricks::TurnWithBallUntilGoal(5, _normalTurnAmount,_maxTurnAmount, 1));
    } else {
      currentTrick = new BasicTricks::MultiTrick(4, new BasicTricks::Kick(LocomotionCommand::TP_GRAB), new BallTricks::WaitForKick(), new BallTricks::TurnWithBallHeadDown(_extraFastTurn), new BallTricks::TurnWithBallUntilGoal(5, _normalTurnAmount,_maxTurnAmount));
    }
    turnTrick = currentTrick;
  }
}

ComplexTricks::ComplexKick::ComplexKick(double _normalTurnAmount, double _maxTurnAmount) {
  currentTrick = NULL;
  turnTrick = NULL;
  // we aren't meant to do a turn. so don't. just choose a kick and start doing it.
  if (_normalTurnAmount == 0.0 && _maxTurnAmount == 0.0) {
    KickSelecta ks;
    currentTrick = ks.FastSelecta(wo_self_->x_, wo_self_->y_, wo_self_->heading_);
  // go the turn !
  } else {
#ifdef ERS_210
    currentTrick = new BallTricks::TurnWithBallUntilGoal(5, _normalTurnAmount,_maxTurnAmount);
#endif
#ifdef ERS_7
//  currentTrick = new BasicTricks::MultiTrick(3, new BasicTricks::Kick(LocomotionCommand::TP_GRAB), new BallTricks::WaitForKick(), new BallTricks::TurnWithBallUntilGoal(_normalTurnAmount,_maxTurnAmount));
    currentTrick = new BasicTricks::MultiTrick(3, new BasicTricks::Kick(LocomotionCommand::TP_GRAB), new BallTricks::WaitForKick(), new BallTricks::TurnWithBallUntilGoal(_normalTurnAmount,_maxTurnAmount, 1)); // used to allow 2 steps but it did 2 when it should have only done 1 (ie min = max = 45)
//  currentTrick = new BasicTricks::MultiTrick(5, new BasicTricks::Kick(LocomotionCommand::TP_GRAB,true), new BallTricks::WaitForKick(), new BallTricks::TurnWithBallUntilGoal(angle,angle,10), new BasicTricks::Kick(LocomotionCommand::TP_CHEST_PUSH,true), new BallTricks::WaitForKick());
#endif
    turnTrick = currentTrick;
  }
}

ComplexTricks::ComplexKick::ComplexKick(Trick* _turnTrick) {
  currentTrick = NULL;
  // we aren't meant to do a turn. so don't. just choose a kick and start doing it.
  if (_turnTrick == NULL) {
    KickSelecta ks;
    Trick* t=ks.FastSelecta(wo_self_->x_, wo_self_->y_, wo_self_->heading_,0);
    currentTrick = new BasicTricks::MultiTrick(3, new BasicTricks::Kick(LocomotionCommand::TP_GRAB), new BallTricks::WaitForKick(), t);
  // go the turn !
  } else {
    currentTrick = _turnTrick;
//  currentTrick = new BallTricks::TurnWithBallUntilGoal(_normalTurnAmount,_maxTurnAmount);
  }
  turnTrick = _turnTrick;
}
ComplexTricks::ComplexKick::~ComplexKick() {
  delete currentTrick;
}
int ComplexTricks::ComplexKick::Start() {
  return currentTrick->Start(); 
}
int ComplexTricks::ComplexKick::Abort() {
  return currentTrick->Abort();
}
int ComplexTricks::ComplexKick::Continue() {
  int cC = currentTrick->Continue();
  // current trick completed.
  if (cC < 1) {
  //char* cMsg = currentTrick->GetErrorMsg(cC);

    // finished our turn with ball trick. evaluate kick !
//  if (strcmp(currentTrick->GetName(),"TurnWithBallUntilGoal")==0) {
    if (turnTrick == currentTrick) {
      turnTrick = NULL;
      delete currentTrick;

      KickSelecta ks;
      // evaluate kick. we may have more information now than we did before sooo :)
      currentTrick = ks.FastSelecta(wo_self_->x_, wo_self_->y_, wo_self_->heading_);
      currentTrick->Start();

    // otherwise we've completed our kick ! get out !
    } else {
      return cC;
    }
  }
  return 40;
}
bool ComplexTricks::ComplexKick::IsUsingHead() {
  return true;
}
char* ComplexTricks::ComplexKick::GetErrorMsg(int m) {
  if (m == 40) {
    return "COMPLEXKICK_IN_PROGRESS";
  } else {
    return currentTrick->GetErrorMsg(m);
  }
}
char* ComplexTricks::ComplexKick::GetName() {
  return "ComplexKick";
}
// END ComplexKick
//////////////////////////////////////////////////////////////////////
// BEGIN TurnWithBallUntilGoal

// END TurnWithBallUntilGoal