playersettings.cpp

2003年RoboCup仿真组世界冠军源代码 足球机器人 仿真组 的源代码

    \return boolean indicating whether update was successful */
bool PlayerSettings::setConeWidth( double d )
{
  dConeWidth = d;
  return true;
}

/*! This method returns the desired end speed for the ball when a normal pass
    is performed.
   \return desired end speed for ball */
double PlayerSettings::getPassEndSpeed( ) const
{
  return dPassEndSpeed;
}

/*! This method sets the desired end speed for the ball when a normal pass is
    performed.
    \param d desired end speed for ball (>0)
    \return boolean indicating whether update was successful */
bool PlayerSettings::setPassEndSpeed( double d )
{
  dPassEndSpeed = d;
  return true;
}

/*! This method returns the desired end speed for the ball when a fast pass is
    performed.
   \return desired end speed for ball when it is passed fast */
double PlayerSettings::getFastPassEndSpeed( ) const
{
  return dFastPassEndSpeed;
}


/*! This method sets the desired end speed for the ball when a fast pass is
    performed.
    \param d desired end speed for passing ball fast (>0)
    \return boolean indicating whether update was successful */
bool PlayerSettings::setFastPassEndSpeed( double d )
{
  dFastPassEndSpeed = d;
  return true;
}

/*! This method returns the x value that can be added to the position of a
    teammate when a leading pass to this teammate is performed.
    \return x value added to teammate to which is passed */
double PlayerSettings::getPassExtraX( ) const
{
  return dPassExtraX;
}

/*! This method sets the x value that is added to the position of a teammate
    when a leading pass is performed.
    \param d x value added to teammate to which is passed
    \return boolean indicating whether update was successful */
bool PlayerSettings::setPassExtraX( double d )
{
  dPassExtraX = d;
  return true;
}

/*! This method returns the fraction of the simulation step that is waited
    before an action is sent to the server in case no see message will arrive
    in this cycle.
    \return fraction of simulation step that is waited when no see arrives */
double PlayerSettings::getFractionWaitNoSee( ) const
{
  return dFractionWaitNoSee;
}

/*! This method sets the fraction of the simulation step that is waited before
    an action is sent to the server in case no see message will arrive in this
    cycle.
    \param d fraction of simulation step that is waited when no see arrives
    (in range [0..1])
    \return boolean indicating whether update was successful */
bool PlayerSettings::setFractionWaitNoSee( double d )
{
  dFractionWaitNoSee = d;
  return true;
}

/*! This method returns the fraction of the simulation step that is waited
    before an action is sent to the server in case the see message will arrive
    in the first half of the cycle.
    \return fraction of simulation step that is waited when see arrives in
            first half of the cycle */
double PlayerSettings::getFractionWaitSeeBegin( ) const
{
  return dFractionWaitSeeBegin;
}

/*! This method sets the fraction of the simulation step that is waited before
    an action is sent to the server in case the see message will arrive in the
    first part of the cycle.
    \param d fraction of simulation step that is waited when see arrives in the
    first half of the cycle (in range [0..1])
    \return boolean indicating whether update was successful */
bool PlayerSettings::setFractionWaitSeeBegin( double d )
{
  dFractionWaitSeeBegin = d;
  return true;
}

/*! This method returns the fraction of the simulation step that is waited
    before an action is sent to the server in case the see message will arrive
    in the second half of the cycle.
    \return fraction of simulation step that is waited when see arrives in
            second half of the cycle */
double PlayerSettings::getFractionWaitSeeEnd( ) const
{
  return dFractionWaitSeeEnd;
}

/*! This method sets the fraction of the simulation step that is waited before
    an action is sent to the server in case the see message will arrive in the
    second part of the cycle.
    \param d fraction of simulation step that is waited when see arrives in the
    second half of the cycle (in range [0..1])
    \return boolean indicating whether update was successful */
bool PlayerSettings::setFractionWaitSeeEnd( double d )
{
  dFractionWaitSeeEnd = d;
  return true;
}

/*! This method returns the desired distance to an opponent which should be
    marked.
    \return desired marking distance to an opponent */
double PlayerSettings::getMarkDistance( ) const
{
  return dMarkDistance;
}

/*! This method sets the desired distance to an opponent which should be
    marked.
    \param d desired marking distance to an opponent
    \return boolean indicating whether update was successful */
bool PlayerSettings::setMarkDistance( double d )
{
  dMarkDistance = d;
  return true;
}

/*! This method returns the radius around the strategic position in which
    an optimal position is considered.
    \return radius around strategic position in which an optimal position is
    considered */
double PlayerSettings::getStratAreaRadius( ) const
{
  return dStratAreaRadius;
}

/*! This method sets the radius around the strategic position in which
    an optimal position is considered.
    \param d radius around strategic position in which an optimal position is
           considered (>0)
    \return boolean indicating whether update was successful */
bool PlayerSettings::setStratAreaRadius( double d )
{
  dStratAreaRadius = d;
  return true;
}

/*! This method returns the minimum needed probability for the ball to enter
    the goal when a "risky" scoring attempt is performed. That is when an agent
    tries to score although the success rate is not very high, he will always
    shoot to a point in the goal where the probability that the ball will enter
    the goal is higher than the value returned by this method.
    \return minimum needed probability that the ball will enter the goal */
double PlayerSettings::getShootRiskProbability( ) const
{
  return dShootRiskProbability;
}


/*! This method sets the minimum needed probability for the ball to enter
    the goal when a "risky" scoring attempt is performed. That is when an agent
    tries to score although the success rate is not very high, he will always
    shoot to a point in the goal where the probability that the ball will enter
    the goal is higher than this value.
    \param d minimum needed probability that the ball enters the goal [0..1]
    \return boolean indicating whether update was successful */
bool PlayerSettings::setShootRiskProbability( double d )
{
  dShootRiskProbability = d;
  return true;
}

/*! This method returns the number of cycles waited by the goalkeeper after he
    has catched the ball.
    \return number of cycles goalkeeper waits after catch */
int PlayerSettings::getCyclesCatchWait( ) const
{
  return iCyclesCatchWait;
}

/*! This method sets the number of cycles waited by the goalkeeper after he
    has catched the ball.
    \param i number of cycles goalkeeper waits after catch
    \return boolean indicating whether update was successful */
bool PlayerSettings::setCyclesCatchWait( int i )
{
  iCyclesCatchWait = i;
  return true;
}

/*! This method returns the number of seconds before the server is assumed
    dead. When no message is received from the server for this amount of
    seconds, it is assumed that the server program has been closed and the
    agent will exits.
    \return number of seconds before server is assumed dead*/
int PlayerSettings::getServerTimeOut( ) const
{
  return iServerTimeOut;
}

/*! This method sets the number of seconds before the server is assumed dead.
    When no message is received from the server for this amount of seconds, it
    is assumed that the server is stopped and the agent exits.
    \param i number of seconds before server is assumed dead
    \return bool indicating whether update was succesfull. */
bool PlayerSettings::setServerTimeOut( int i )
{
  iServerTimeOut = i;
  return true;
}

/*! This method returns the threshold to determine when the agent turns towards
    the dribble direction when dribbling. When the global angle
    difference is larger than this value, the agent performs a turnWithBallTo.
   \return threshold value for angle */
double PlayerSettings::getDribbleAngThr( ) const
{
  return dDribbleAngThr;
}

/*! This method sets the threshold to determine when the agent turns towards
    the dribble direction when dribbling. When the global angle
    difference is larger than this value, the agent performs a turnWithBallTo.
    \param d threshold value for angle
    \return bool indicating whether update was succesfull. */
bool PlayerSettings::setDribbleAngThr( double d )
{
  dDribbleAngThr = d;
  return true;
}


/*! This method returns the threshold to determine when the ball is kicked to
    another position in the turnWithBallTo skill. When the global angle
    difference is larger than this value, the ball is repositioned otherwise
    it is not.
   \return threshold value for angle */
double PlayerSettings::getTurnWithBallAngThr( ) const
{
  return dTurnWithBallAngThr;
}

/*! This method sets the threshold to determine when the ball is kicked to
    another position in the turnWithBallTo skill. When the global angle
    difference is larger than this value, the ball is repositioned otherwise
    it is not.
    \param d threshold value for angle
    \return bool indicating whether update was succesfull. */
bool PlayerSettings::setTurnWithBallAngThr( double d )
{
  dTurnWithBallAngThr = d;
  return true;
}

/*! This method returns the threshold to determine when the ball is frozen
    in the turnWithBallTo skill. When the ball speed is larger than this value,
    the ball is frozen otherwise not
    \return threshold value for freezing the ball */
double PlayerSettings::getTurnWithBallFreezeThr( ) const
{
  return dTurnWithBallFreezeThr;
}

/*! This method sets the threshold to determine when the ball is frozen
    in the turnWithBallTo skill. When the ball speed is larger than this value,
    the ball is frozen otherwise not
    \param d threshold value for freezing the ball
    \return bool indicating whether update was succesfull. */
bool PlayerSettings::setTurnWithBallFreezeThr( double d )
{
  dTurnWithBallFreezeThr = d;
  return true;
}

/*! This method returns the initial formation of the team.
    \return number of cycles goalkeeper waits after catch */
int PlayerSettings::getInitialFormation( ) const
{
  return iInitialFormation;
}

/*! This method sets the initial formation of the team.
    \param i initital formation of the team
    \return boolean indicating whether update was successful */
bool PlayerSettings::setInitialFormation( int i )
{
  iInitialFormation = i;
  return true;
}

/*! This method returns the percentage of the field width. The corresponding y
    position is the maximum allowed y position for a player's strategic
    position.
    \return maximum y percentage on the field.  */
double PlayerSettings::getMaxYPercentage( ) const
{
  return dMaxYPercentage;
}

/*! This method sets the percentage of the field width. The corresponding y
    position is the maximum allowed y position for a player's strategic
    position.
    \param d percentage of the field width
    \return bool indicating whether update was succesfull. */
bool PlayerSettings::setMaxYPercentage( double d )
{
  dMaxYPercentage = d;
  return true;
}