instintive.cpp.svn-base

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

      bNovaMsg = true;
   }
/*   if ( bNovaMsg)
   {
      inferenceEngine.inference();
      //mFactsBase.print();      
   }
*/
   return bNovaMsg;
}

void Instintive::update(LocalGoal lc)
{
   mFactsBase.addLogicPattern("local_goal", "current", lc.current );
   mFactsBase.addLogicPattern("local_goal", "status", lc.status );
}

/*! Este metodo verifica se a bola esta em posse de algum jogador de meio campo, ou seja o 6, 7 ou 8. 
    \return verdadeiro se a bola pertence aos jogadores do meio campo, falso casos contr�rio. */
bool Instintive::isBallInMidplayerPossesion()
{
   int     iCyc;
   ObjectT o = WM->getFastestInSetTo( OBJECT_SET_PLAYERS, OBJECT_BALL, &iCyc );

   if( o == OBJECT_ILLEGAL )
      return false;
   if( (o ==  OBJECT_TEAMMATE_6) or (o ==  OBJECT_TEAMMATE_7) or (o ==  OBJECT_TEAMMATE_8) )
      return true;
   else
      return false;
}

/*! Este metodo verifica se a bola esta em posse de algum jogador de meio campo, ou seja o 9, 10 ou 11. 
    \return verdadeiro se a bola pertence aos jogadores do meio campo, falso casos contr�rio. */
bool Instintive::isBallInAttackplayersPossesion()
{
   int     iCyc;
   ObjectT o = WM->getFastestInSetTo( OBJECT_SET_PLAYERS, OBJECT_BALL, &iCyc );

   if( o == OBJECT_ILLEGAL )
      return false;
   if( (o ==  OBJECT_TEAMMATE_9) or (o ==  OBJECT_TEAMMATE_10) or (o ==  OBJECT_TEAMMATE_11) )
      return true;
   else
      return false;
}

/*! Este metodo retorna a localizacao em area do jogador em campo. A pricipio
    o campo sera dividido em tres areas, defesa, estrategica e ataque.
    \return a principio um int correpondente a area. */
PlayerPositionT Instintive::getLocalization( VecPosition position )
{
   int xA = 0;
   int xB = 32;
   int xC = 60;
   int xD = 15;
   int yB = 14;
   int yC = 33;

   VecPosition posAgent = position;	

   //if (posAgent.getX() <= xA )
   VecPosition p1Area(-xB,yB);
   VecPosition p2Area(-xC,-yB);
   Rect rectangle(p1Area,p2Area);
   if ( rectangle.isInside( posAgent ) )
      return AREA_DEFENSE;

   // pontos que definem a area retangular de ataque
   p1Area.setX(xB);
   p1Area.setY(yB);
   p2Area.setX(xC);
   p2Area.setY(-yB);
   rectangle.setRectanglePoints(p1Area,p2Area);
   if ( rectangle.isInside( posAgent ) )
      return AREA_ATTACK; // ataque 

   p1Area.setX(-xD);
   p1Area.setY(yB);
   p2Area.setX(xD);
   p2Area.setY(-yB);
   rectangle.setRectanglePoints(p1Area,p2Area);
   if ( rectangle.isInside( posAgent ) )
      return AREA_CENTRAL;

   p1Area.setX(-xB);
   p1Area.setY(yB);
   p2Area.setX(xB);   
   p2Area.setY(yC);
   rectangle.setRectanglePoints(p1Area,p2Area);
   if ( rectangle.isInside( posAgent ) )
      return AREA_SIDE;

   p1Area.setY(-yB);
   p2Area.setY(-yC);
   rectangle.setRectanglePoints(p1Area,p2Area);
   if ( rectangle.isInside( posAgent ) )
      return AREA_SIDE;

   p1Area.setX(xB);
   p1Area.setY(yB);
   p2Area.setX(xC);
   p2Area.setY(yC);
   rectangle.setRectanglePoints(p1Area,p2Area);
   if ( rectangle.isInside( posAgent ) )
      return AREA_SIDE_ATTACK;

   p1Area.setY(-yB);
   p2Area.setY(-yC);
   rectangle.setRectanglePoints(p1Area,p2Area);
   if ( rectangle.isInside( posAgent ) )
      return AREA_SIDE_ATTACK;

   p1Area.setX(xB);
   p1Area.setY(yB);
   p2Area.setX(xD);
   p2Area.setY(-yB);
   rectangle.setRectanglePoints(p1Area,p2Area);
   if ( rectangle.isInside( posAgent ) )
      return AREA_CENTRAL_ATTACK;

   p1Area.setX(-xB);
   p1Area.setY(yB);
   p2Area.setX(-xC);
   p2Area.setY(yC);
   rectangle.setRectanglePoints(p1Area,p2Area);
   if ( rectangle.isInside( posAgent ) )
      return AREA_SIDE_DEFENSE;

   p1Area.setY(-yB);
   p2Area.setY(-yC);
   rectangle.setRectanglePoints(p1Area,p2Area);
   if ( rectangle.isInside( posAgent ) )
      return AREA_SIDE_DEFENSE;

   p1Area.setX(-xB);
   p1Area.setY(yB);
   p2Area.setX(-xD);
   p2Area.setY(-yB);
   rectangle.setRectanglePoints(p1Area,p2Area);
   if ( rectangle.isInside( posAgent ) )
      return AREA_CENTRAL_DEFENSE;

   return AREA_ILLEGAL;
}

/*! Este metodo retorna um valor real indicando a confiabilidade do passe.
    \param recebe o identificador do companheiro de time que dever� receber a bola.
    \return o nivel de confiabilidade do passe.*/
bool Instintive::confidenceToPass( ObjectT teamMate )
{
   VecPosition posTeamMate = WM->getGlobalPosition(teamMate);
   VecPosition posAgent = WM->getAgentGlobalPosition();
   if ( WM->isVisible( teamMate ) and ( getSafetyToPass( posAgent , posTeamMate ) > 1.1 ))
      return true;
   else
      return false;
}

/*! Este método retorna um valor booleano representando a confiabilidade do chute à gol. Ou seja caso esse método retornar verdadeiro significa que o chute muito provavelmente resultará num gol.
*/
bool Instintive::confidenceToKick( )
{//analizar este metodo, pois ainda não está satisfatório...
   VecPosition posAgent = WM->getAgentGlobalPosition();
   VecPosition posGoalCenter, posGoalRight, posGoalLeft;
   double option1, option2, option3, option11, option22, option33;
   posGoalCenter.setX(52.5);
   posGoalCenter.setY(0.0);
   posGoalRight.setX(52.5);
   posGoalRight.setY(6.5);
   posGoalLeft.setX(52.5);
   posGoalLeft.setY(-6.5);
   /*if( WM->getGlobalPosition(OBJECT_OPPONENT_GOALIE).getX() < WM->getAgentGlobalPosition().getX() and WM->getAgentGlobalPosition().getY() < 10 and WM->getAgentGlobalPosition().getY() > -10 )
      return true;*/
   if( WM->isVisible(OBJECT_OPPONENT_1) )
   {
      option1 = getSafetyToPass( posAgent , posGoalCenter );
      option11 = getSafetyToKick( posAgent , posGoalCenter );
      option2 = getSafetyToPass( posAgent , posGoalRight );
      option22 = getSafetyToKick( posAgent , posGoalRight );
      option3 = getSafetyToPass( posAgent , posGoalLeft );
      option33 = getSafetyToKick( posAgent , posGoalLeft );
      if( ( option1 > 1.1 && option11 > 1.1 ) || (option2 > 1.1 && option22 > 1.1 ) || (option3 > 1.1 && option33 > 1.1 ) )
         return true;
   }
   if( (WM->getAgentGlobalPosition().getX() < WM->getGlobalPosition(OBJECT_OPPONENT_1).getX()) and (WM->getAgentGlobalPosition().getY() < 14 and WM->getAgentGlobalPosition().getY() > -14) )
      return true;
   return false;
}
/*! Este metodo retorna um valor real indicando a possibilidade de chute mais confiável.
    \return posição confiável de chute.*/
string Instintive::bestOptionForKick( )
{
   VecPosition posAgent = WM->getAgentGlobalPosition();
   VecPosition posGoalCenter, posGoalRight, posGoalLeft;
   double option1, option2, option3, option11, option22, option33, teste;
   string option;
   posGoalCenter.setX(52.5);
   posGoalCenter.setY(0.0);
   posGoalRight.setX(52.5);
   posGoalRight.setY(6.5);
   posGoalLeft.setX(52.5);
   posGoalLeft.setY(-6.5);
   /*if( WM->isVisible(OBJECT_OPPONENT_GOALIE) )
   {*/
      /*if( WM->getGlobalPosition(OBJECT_OPPONENT_GOALIE).getX() < WM->getAgentGlobalPosition().getX() and WM->getAgentGlobalPosition().getY() < 10 and WM->getAgentGlobalPosition().getY() > -10 )
         return "center";*/
      option1 = getSafetyToPass( posAgent , posGoalCenter );
      option11 = getSafetyToKick( posAgent , posGoalCenter );
      if( option1 > 1.1 && option11 > 1.1 )
      {
         //if( WM->getPlayerNumber() == 9 )
            //cout<<"Chute!!!"<<endl<<"jog: "<<option1<<endl<<"gol: "<<option11<<endl;
         return "center";
      }
      option2 = getSafetyToPass( posAgent , posGoalRight );
      option22 = getSafetyToKick( posAgent , posGoalRight );
      option3 = getSafetyToPass( posAgent , posGoalLeft );
      option33 = getSafetyToKick( posAgent , posGoalLeft );
      if( option11 < option22 )
      {
         if( option22 < option33 )
            option = "left";
         else
            option = "right";
      }
      else
      {
         if( option11 < option33 )
            option = "left";
         else
            option = "center";
      }
      /*if( WM->getPlayerNumber() == 9 )
      {
         cout<<"CENTER: "<<option11<<endl;
         cout<<"RIGHT: "<<option22<<endl;
         cout<<"LEFT: "<<option33<<endl;
         cout<<"Opção: "<<option<<endl;
      }*/
      return option;
   /*}
   else
      return "none";*/
}

/*!Este metodo verifica onde esta posicionado mais proximo do agente*/
string Instintive::getOpponentLocalization()
{
   VecPosition posAgent = WM->getAgentGlobalPosition();
   ObjectT opponent = WM->getClosestInSetTo( OBJECT_SET_OPPONENTS , posAgent );
   VecPosition posOppon = WM->getGlobalPosition( opponent );
   if( posAgent.getX() > posOppon.getX() )
      return "back";
   if( posAgent.getY() - posOppon.getY() < 0.25 && posAgent.getY() - posOppon.getY() > -0.25 && posAgent.getX() - posOppon.getX() < 2.5 )
      return "front";
   else if( posAgent.getY() > posOppon.getY() )
      return "left";
   else
      return "right";
}

/*! Este método verifica nas situações de bola parada de quem é a bola
\return De quem é a bola nossa, ou dos adversários*/
string Instintive::ModeUsOrThem( )
{
   PlayModeT pm = WM->getPlayMode();
   if(  WM->isDeadBallUs(pm) )
      return "us";
   if( WM->isDeadBallThem(pm) )
      return "them";
   return "none";
}

string Instintive::getModeUsOrThemString()
{
   PlayModeT pm = WM->getPlayMode();
   if(WM->isFreeKickUs(pm))
      return "free_kick_us";
   if(WM->isFreeKickThem(pm))
      return "free_kick_them";
   if(WM->isCornerKickUs(pm))
      return "corner_kick_us";
   if(WM->isCornerKickThem(pm))
      return "corner_kick_them";
   if(WM->isOffsideUs(pm))
      return "offside_us";
   if(WM->isOffsideThem(pm))
      return "offside_them";
   if(WM->isKickInUs(pm))
      return "kick_in_us";
   if(WM->isKickInThem(pm))
      return "kick_in_them";
   if(WM->isFreeKickFaultUs(pm))
      return "free_kick_fault_us";
   if(WM->isFreeKickFaultThem(pm))
      return "free_kick_fault_them";
   if(WM->isKickOffUs(pm))
      return "kick_off_us";
   if(WM->isKickOffThem(pm))
      return "kick_off_them";
   if(WM->isBackPassUs(pm))
      return "back_pass_us";
   if(WM->isBackPassThem(pm))
      return "back_pass_them";
   if(WM->isGoalKickUs(pm))
      return "goal_kick_us";
   if(WM->isGoalKickThem(pm))
      return "goal_kick_them";
   if(WM->isPenaltyUs(pm))
      return "penalty_us";
   if(WM->isPenaltyThem(pm))
      return "penalty_them";
   switch (pm)
   {
      case PM_BEFORE_KICK_OFF:
         return "PM_BEFORE_KICK_OFF";
      case PM_PLAY_ON:
         return "PM_PLAY_ON";
      case PM_TIME_OVER:
         return "PM_TIME_OVER";
      case PM_FROZEN:
         return "PM_FROZEN";
      case PM_QUIT:
         return "PM_QUIT";
   }
   return "illegal";
}

/*! Este método verifica se o agente está cansado.
*/
bool Instintive::teammateIsSick()
{
   if( WM->getAgentStamina().getStamina() >     // if stamina high
       SS->getRecoverDecThr()*SS->getStaminaMax()+800 )
      return false;
   return true;
}

/*! Este método deverá delimitar uma área para cada agente, e verificar se o objeto (bola) encontra-se nesta área. Sendo esa sua área prioritária de ação.