instintive.cpp.svn-base

来自「一个巴西大学编写的2D仿真组足球机器人程序」· SVN-BASE 代码 · 共 1,358 行 · 第 1/4 页

*/
bool Instintive::atuationZone( VecPosition pos )
{
   double xA = -40.0;
   double xB = -22.5;
   double xC = -25.0;
   double xD = -12.5;
   double xE = -10.0;
   double xF = 2.5;
   double yA = 7.0;
   double yB = 9.5;
   double yC = 23.5;
   double n = WM->getPlayerNumber();
   VecPosition p1Area;
   VecPosition p2Area;
   if ( n == 2 )
   {
      p1Area.setX(xA);
      p1Area.setY(yB);
      p2Area.setX(xB);
      p2Area.setY(yC);
   }
   else if ( n == 3 )
   {
      p1Area.setX(xA);
      p1Area.setY(-yA);
      p2Area.setX(xB);
      p2Area.setY(yA);
   }
   else if ( n == 4 )
   {
      p1Area.setX(xC);
      p1Area.setY(-yA);
      p2Area.setX(xD);
      p2Area.setY(yA);
   }
   else if ( n == 5 )
   {
      p1Area.setX(xA);
      p1Area.setY(-yB);
      p2Area.setX(xB);
      p2Area.setY(-yC);
   }
   else if ( n == 6 )
   {
      p1Area.setX(xC);
      p1Area.setY(-yB);
      p2Area.setX(xD);
      p2Area.setY(-yC);
   }
   else if ( n == 7 )
   {
      p1Area.setX(xC);
      p1Area.setY(yB);
      p2Area.setX(xD);
      p2Area.setY(yC);
   }
   else if ( n == 8 )
   {
      p1Area.setX(xE);
      p1Area.setY(-yA);
      p2Area.setX(xF);
      p2Area.setY(yA);
   }
   else if (( n == 9 )||( n == 10 )||( n == 11 ))
   {
      return false;
   }
   Rect rectangle(p1Area,p2Area);
   rectangle.setRectanglePoints(p1Area,p2Area);
   if ( rectangle.isInside( pos ) )
      return true;
   return false;
}

/*! Este metodo retorna um valor real quer representa a seguranca de passar 
    a bola. Quanto maior este valor menos risco o time corre de perder a bola
    no mento do passe. Este valor e encontrado analisando a distancia do 
    jogador mais proximo do time adversario a reta que e formada entre o 
    agente e seu companheiro que receberar o passe.
    \param posA posicao global do agente no campo
    \param posM posicao global do companheiro no campo
    \return valor que representa a seguran�a de passar a bola */
double Instintive::getSafetyToPass( VecPosition posA, VecPosition posM )
{
   // distancia do openente a linha formada entre o agente e seu companheiro
   double dLine;
   // distancia do agente a projecao 
   double dProj;
   Line line = Line::makeLineFromTwoPoints( posA, posM );
   WM->getClosestInSetTo(OBJECT_SET_OPPONENTS, line, posA, posM, &dLine, &dProj);
//   cout<<dLine<<", "<<dProj<<endl;
   return (2.0*dLine)/dProj;
}

/*! Este método é uma adaptação do método acima, a diferença é sua exclusividade para chute à gol, pois o jogador a ser analisado será o goleiro do time adversário
    \param posA posicao global do agente no campo
    \param posM posicao global do companheiro no campo
    \return valor que representa a seguran�a de passar a bola */
double Instintive::getSafetyToKick( VecPosition posA, VecPosition posM )
{
   // distancia do openente a linha formada entre o agente e seu companheiro
   double dLine;
   // distancia do agente a projecao 
   double dProj;
   Line line = Line::makeLineFromTwoPoints( posA, posM );
   getClosestInSetTo(line, posA, posM, &dLine, &dProj);
//   cout<<dLine<<", "<<dProj<<endl;
   return (2.0*dLine)/dProj;
}

/*!Este metodo verifica se o oponente mais proximo possui a bola
*/
bool Instintive::closeOpponentHasBall()
{
   ObjectT opponent = WM->getClosestInSetTo( OBJECT_SET_OPPONENTS , WM->getAgentGlobalPosition() );
   if( WM->getClosestInSetTo( OBJECT_SET_OPPONENTS , OBJECT_BALL ) == opponent )
      return true;
   else
      return false;
}

/*! Este m�todo usar o retorno de getPlayerLocalization() para gerar um string contedo o nome da �rea onde esta localizado o agente 
   \return uma string que representa a localiza��o*/
string Instintive::getLocalizationString(VecPosition position)
{
   PlayerPositionT pos = getLocalization(position);
   switch (pos){
      case AREA_ATTACK:
         return "AREA_ATTACK";
      case AREA_DEFENSE:
         return "AREA_DEFENSE";
      case AREA_SIDE_ATTACK:
         return "AREA_SIDE_ATTACK";
      case AREA_SIDE:
         return "AREA_SIDE";
      case AREA_CENTRAL:
         return "AREA_CENTRAL";
      case AREA_CENTRAL_ATTACK:
         return "AREA_CENTRAL_ATTACK";
      case AREA_CENTRAL_DEFENSE:
         return "AREA_CENTRAL_DEFENSE";
      case AREA_SIDE_DEFENSE:
         return "AREA_SIDE_DEFENSE";
      case AREA_ILLEGAL:
         return "AREA_ILLEGAL";
   }
   return "AREA_ILLEGAL";
}
string Instintive::getPlayModeString()
{
   PlayModeT PlayMode = WM->getPlayMode();
   switch (PlayMode){
      case PM_BEFORE_KICK_OFF:
         return "PM_BEFORE_KICK_OFF";
      case PM_KICK_OFF_LEFT:
         return "PM_KICK_OFF_LEFT";	
      case PM_KICK_OFF_RIGHT:
         return "PM_KICK_OFF_RIGHT";
      case PM_KICK_IN_LEFT:
         return "PM_KICK_IN_LEFT";	
      case PM_KICK_IN_RIGHT:
         return "PM_KICK_IN_RIGHT";
      case PM_CORNER_KICK_LEFT:
         return "PM_CORNER_KICK_LEFT";	
      case PM_CORNER_KICK_RIGHT:
         return "PM_CORNER_KICK_RIGHT"; 
      case PM_GOAL_KICK_LEFT:
         return "PM_GOAL_KICK_LEFT";
      case PM_GOAL_KICK_RIGHT:
         return "PM_GOAL_KICK_RIGHT";
      case PM_GOAL_LEFT:
         return "PM_GOAL_LEFT";
      case PM_GOAL_RIGHT:
         return "PM_GOAL_RIGHT";
      case PM_FREE_KICK_FAULT_LEFT:
         return "PM_FREE_KICK_FAULT_LEFT";
      case PM_FREE_KICK_FAULT_RIGHT:
         return "PM_FREE_KICK_FAULT_RIGHT";
      case PM_FREE_KICK_LEFT:
         return "PM_FREE_KICK_LEFT";
      case PM_FREE_KICK_RIGHT:
         return "PM_FREE_KICK_RIGHT";
      case PM_INDIRECT_FREE_KICK_RIGHT:
         return "PM_INDIRECT_FREE_KICK_RIGHT";
      case PM_INDIRECT_FREE_KICK_LEFT:
         return "PM_INDIRECT_FREE_KICK_LEFT";
      case PM_BACK_PASS_LEFT:
         return "PM_BACK_PASS_LEFT";
      case PM_BACK_PASS_RIGHT:
         return "PM_BACK_PASS_RIGHT";
      case PM_OFFSIDE_LEFT:
         return "PM_OFFSIDE_LEFT";
      case PM_OFFSIDE_RIGHT:
         return "PM_OFFSIDE_RIGHT";
      case PM_PLAY_ON:
         return "PM_PLAY_ON";
      case PM_TIME_OVER:
         return "PM_TIME_OVER";
      case PM_PENALTY_SETUP_LEFT:
         return "PM_PENALTY_SETUP_LEFT";
      case PM_PENALTY_SETUP_RIGHT:
         return "PM_PENALTY_SETUP_RIGHT";
      case PM_PENALTY_READY_LEFT:
         return "PM_PENALTY_READY_LEFT";
      case PM_PENALTY_READY_RIGHT:
         return "PM_PENALTY_READY_RIGHT";
      case PM_PENALTY_TAKEN_LEFT:
         return "PM_PENALTY_TAKEN_LEFT";
      case PM_PENALTY_TAKEN_RIGHT:
         return "PM_PENALTY_TAKEN_RIGHT";
      case PM_FROZEN:
         return "PM_FROZEN";
      case PM_QUIT:
         return "PM_QUIT";
   }
   return "PM_ILLEGAL";
}

/*! Este m�todo retorna entre dois agentes qual agente se encontra mais pr�ximo do jogador com a bola
Antes disso esta função verifica a confiança do passe.
*/
ObjectT Instintive::objectTeammateCloser( ObjectT obj1, ObjectT obj2 )
{
   double distanceObj1 = WM->getRelativeDistance( obj1 );
   double distanceObj2 = WM->getRelativeDistance( obj2 );
   VecPosition posAgent = WM->getAgentGlobalPosition();

   if( (getSafetyToPass(posAgent, obj1) > getSafetyToPass(posAgent, obj2))and(confidenceToPass(obj2)) )
      return obj2;
   if( (getSafetyToPass(posAgent, obj1) < getSafetyToPass(posAgent, obj2))and(confidenceToPass(obj1)) )
      return obj1;
   if ( distanceObj1 <= distanceObj2 ) return ( obj1 );
   else return ( obj2 );
}


/*! Este método retorna a posição atual do goleiro em relação ao jogador, se o goleiro estiver mais para o lado esquerdo da trave na visão do jogador ele retorna "LEFT", ou ainda se ele estiver mais para o lado direito ele retorna "RIGHT"*/
// string Instintive::getPositionYOpponent1()
// {
//    if( (WM->isKnownPlayer( OBJECT_OPPONENT_1 )) && (getPlayerLocalization() == AREA_ATTACK))
//    {
//       if(WM->getSide() == SIDE_LEFT)
//       {
//          //verifica se o goleiro esta fora da area de chute a gol, do lado esquerdo do campo.
//          if( abs((int)WM->getRelativeAngle( OBJECT_FLAG_G_L_T, false) - (int)WM->getRelativeAngle( OBJECT_GOAL_L, false )) < abs( (int)WM->getRelativeAngle( OBJECT_OPPONENT_1, false) - (int)WM->getRelativeAngle( OBJECT_GOAL_L, false )))
//          return ("AWAY");
// 
//          //verifica qual angulo esta mais aberto para o chute.
//          else if( abs((int)WM->getRelativeAngle( OBJECT_FLAG_G_L_T, false )-  (int)WM->getRelativeAngle(OBJECT_OPPONENT_1,false))  >  abs((int)WM->getRelativeAngle(OBJECT_OPPONENT_1,false) - (int)WM->getRelativeAngle(OBJECT_FLAG_G_L_B,false) ) ) 
//          return ("LEFT");
// 
//          else return ("RIGHT");
//       }
//       else if( WM->getSide() == SIDE_RIGHT)
//       {
//          //verifica se o goleiro esta fora da area de chute a gol, do lado direito do campo.
//          if( abs((int)WM->getRelativeAngle( OBJECT_FLAG_G_R_T, false) - (int)WM->getRelativeAngle( OBJECT_GOAL_R, false )) < abs( (int)WM->getRelativeAngle( OBJECT_OPPONENT_1, false) - (int)WM->getRelativeAngle( OBJECT_GOAL_R, false )))
//          return ("AWAY");
//  
//          //verifica qual angulo esta mais aberto para o chute.
//          else if( abs( (int)WM->getRelativeAngle(OBJECT_FLAG_G_R_T,false) - (int)WM->getRelativeAngle(OBJECT_OPPONENT_1,false)) > abs( (int)WM->getRelativeAngle(OBJECT_OPPONENT_1,false) - (int)WM->getRelativeAngle(OBJECT_FLAG_G_R_B,false))) 
//          return ("RIGHT");
//  
//          else return ("LEFT");
//       }
//    }
//    else return ("UNKNOWN");
// }

/************************* Métodos do WorldModel Adaptados *************************/

/*! Este método é uma réplica do método getListCloseOpponents do WorldModel, que analisa se há jogador em volta dele, já este novo método deverá analizar se tem oponente à sua frente ou atrás se estiver mais proximo, pois um oponente que se encontrar atrás não deverá oferecer tanto perigo.*/
list<ObjectT> Instintive::getListCloseOpponents( VecPosition pos,double dDist,double dDist2 )
{
  int iIndex;
  list<ObjectT> listOpp;

  for( ObjectT o = WM->iterateObjectStart( iIndex, OBJECT_SET_OPPONENTS );
       o != OBJECT_ILLEGAL;
       o = WM->iterateObjectNext ( iIndex, OBJECT_SET_OPPONENTS  ) )
  {
    if((( WM->getGlobalPosition( o ).getDistanceTo( pos ) < dDist )and( WM->getGlobalPosition( o ).getX() > pos.getX() )) || (( WM->getGlobalPosition( o ).getDistanceTo( pos ) < dDist2 )and( WM->getGlobalPosition( o ).getX() < pos.getX() )))
      listOpp.push_back( o );
  }
  WM->iterateObjectDone( iIndex );
  return listOpp;
}

/*! Esta adptação consiste em analizar apenas o goleiro, sendo que este método dará suporte ao chute à gol.

    This method returns the closest object in 'set' to the line
    'l'. The projection p of the global position of this object on the
    line 'l' should lie between pos1 and pos2. After the method is
    finished, it returns this object and the last two arguments of
    this method are set to the the distance between the object and p
    and the distance from pos1 to p respectively.

    \param set ObjectSetT which denotes objects taken into consideration
    \param l line to which opponents should be projected
    \param pos1 minimum allowed projection point
    \param pos2 maximum allowed projection point
    \param dDistObjToLine will contain distance from opponent to line l
    \param dDistPos1ToPoint will contain distance from pos1 to projection point
    opponent on line l
    \return object type of closest object to line l */
ObjectT Instintive::getClosestInSetTo( Line l,
                              VecPosition pos1, VecPosition pos2,
                              double *dDistObjToLine, double *dDistPos1ToPoint)
{
  VecPosition posObj;
  VecPosition posOnLine;
  double      dConfThr  = PS->getPlayerConfThr();
  ObjectT     obj       = OBJECT_ILLEGAL;
  ObjectT     o         = OBJECT_OPPONENT_1;
  double      dDist     ;
  double      dMinDist  = 1000.0;
  double      dDistPos1 = 1000.0;
  int         iIndex;

    posObj    = WM->getGlobalPosition( o );
    posOnLine = l.getPointOnLineClosestTo( posObj );
    dDist     = posObj.getDistanceTo( posOnLine );
    if( l.isInBetween( posOnLine, pos1, pos2 ) && dDist < dMinDist )
    {
      dMinDist  = dDist;
      obj       = o;
      dDistPos1 = pos1.getDistanceTo( posOnLine );
    }
  if( dDistObjToLine != NULL )
    *dDistObjToLine = dMinDist;
  if( dDistPos1ToPoint != NULL )
    *dDistPos1ToPoint = dDistPos1;

  return obj;
}