playersettings.cpp

自己写的robocup-2d程序

/*
Copyright (c) 2000-2003, Jelle Kok, University of Amsterdam
All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

1. Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.

2. Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.

3. Neither the name of the University of Amsterdam nor the names of its
contributors may be used to endorse or promote products derived from this
software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

/*! \file PlayerSettings.cpp
<pre>
<b>File:</b>          PlayerSettings.cpp
<b>Project:</b>       Robocup Soccer Simulation Team: UvA Trilearn
<b>Authors:</b>       Jelle Kok
<b>Created:</b>       28/11/2000
<b>Last Revision:</b> $ID$
<b>Contents:</b>      Code file for class PlayerSettings. It contains all the
               member method implementations of the PlayerSettings class.
               This class contains all the settings that are important
               for the client (agent) to determine its actions.
<hr size=2>
<h2><b>Changes</b></h2>
<b>Date</b>             <b>Author</b>          <b>Comment</b>
28/11/2000       Jelle Kok       Initial version created
</pre>
*/

#include "PlayerSettings.h"

/*****************************************************************************/
/********************* CLASS PlayerSettings **********************************/
/*****************************************************************************/

/*! This method initializes all client settings and adds these to the generic
    values class with the effect that they can referenced by their textual
    name. */
PlayerSettings::PlayerSettings( ) : GenericValues("PlayerSettings", 27)
{
  dPlayerConfThr         = 0.88; // threshold below player info is illegal
  dPlayerHighConfThr     = 0.92; // threshold above which player info is high
  dBallConfThr           = 0.90; // threshold below which ball info is illegal
  dPlayerDistTolerance   = 7.5;  // distance when unknownplayer is mapped
  dPlayerWhenToTurnAngle = 7.0;  // angle when to turn when moving
  dPlayerWhenToKick      = 0.85; // % of kick power rate when kick is performed
  iPlayerWhenToIntercept = 30;   // maximum number of interception cycles
  dClearBallDist         = 5.0;  // dist before penalty area to clear ball to
  dClearBallOppMaxDist   = 30.0; // radius in which opp in clear ball has to be
  dClearBallToSideAngle  = 17.0; // minimum angle for clear ball to side
  dConeWidth             = 0.5;  // cone width to check for opponents in pass
  dPassEndSpeed          = 1.2;  // end speed for ball when passed to teammate
  dFastPassEndSpeed      = 1.8;  // end speed for ball when passed fast
  dPassExtraX            = 0.0;  // extra x value added to player passing pos
  dFractionWaitNoSee     = 0.61;  // % of cycle to wait in cycle with no see
  dFractionWaitSeeBegin  = 0.70; // % to wait in cycle with see in begin
  dFractionWaitSeeEnd    = 0.85; // % to wait in cycle with see in 2nd  half
  dMarkDistance          = 5.0;  // mark distance to a player
  dStratAreaRadius       = 5.0;  // radius around strat pos to find optimal pos
  dShootRiskProbability  = 0.88; // prob. of scoring when shooting with risk
  iCyclesCatchWait       = 20;   // cycles to wait after a catch
  iServerTimeOut         = 9;    // seconds before server is assumed dead
  dDribbleAngThr         = 20.0; // angle thr. to turn to ball before dribbling
  dTurnWithBallAngThr    = 45.0; // angle threshold to kick ball
  dTurnWithBallFreezeThr = 0.2;  // ball speed threshold to freeze ball
  iInitialFormation      = 2;    // initial formation number
  dMaxYPercentage        = 0.8;  // max y in strat. pos (percentage of field)

  // add all the settings and link text string to variable
  addSetting( "player_conf_thr"     , &dPlayerConfThr,  GENERIC_VALUE_DOUBLE );
  addSetting( "player_high_conf_thr", &dPlayerHighConfThr,
                                                        GENERIC_VALUE_DOUBLE );
  addSetting( "ball_conf_thr"      ,  &dBallConfThr,    GENERIC_VALUE_DOUBLE );
  addSetting( "player_dist_tolerance",&dPlayerDistTolerance,
                                                        GENERIC_VALUE_DOUBLE );
  addSetting( "player_when_to_turn",  &dPlayerWhenToTurnAngle,
                                                        GENERIC_VALUE_DOUBLE );
  addSetting( "player_when_to_kick", &dPlayerWhenToKick,GENERIC_VALUE_DOUBLE );
  addSetting( "player_when_to_intercept",&iPlayerWhenToIntercept,
                                                        GENERIC_VALUE_INTEGER);
  addSetting( "clear_ball_dist"    ,  &dClearBallDist,  GENERIC_VALUE_DOUBLE );
  addSetting( "clear_ball_opp_max_dist", &dClearBallOppMaxDist,
                                                        GENERIC_VALUE_DOUBLE );
  addSetting( "clear_ball_side_angle", &dClearBallToSideAngle,
                                                        GENERIC_VALUE_DOUBLE );
  addSetting( "cone_width"         ,  &dConeWidth,      GENERIC_VALUE_DOUBLE );
  addSetting( "pass_end_speed"     ,  &dPassEndSpeed,   GENERIC_VALUE_DOUBLE );
  addSetting( "fast_pass_end_speed", &dFastPassEndSpeed,GENERIC_VALUE_DOUBLE );
  addSetting( "pass_extra_x"       ,  &dPassExtraX,     GENERIC_VALUE_DOUBLE );
  addSetting( "wait_no_see"        ,&dFractionWaitNoSee,GENERIC_VALUE_DOUBLE );
  addSetting( "wait_see_begin" , &dFractionWaitSeeBegin,GENERIC_VALUE_DOUBLE );
  addSetting( "wait_see_end"    , &dFractionWaitSeeEnd, GENERIC_VALUE_DOUBLE );
  addSetting( "mark_distance"      ,  &dMarkDistance,   GENERIC_VALUE_DOUBLE );
  addSetting( "strat_area_radius"  ,  &dStratAreaRadius,GENERIC_VALUE_DOUBLE );
  addSetting( "shoot_risk_prob", &dShootRiskProbability,GENERIC_VALUE_DOUBLE );
  addSetting( "cycles_catch_wait"  ,  &iCyclesCatchWait,GENERIC_VALUE_INTEGER);
  addSetting( "server_time_out"    ,  &iServerTimeOut,  GENERIC_VALUE_INTEGER);
  addSetting( "dribble_ang_thr"    ,  &dDribbleAngThr,  GENERIC_VALUE_DOUBLE );
  addSetting( "turn_with_ball_ang_thr" , &dTurnWithBallAngThr,
                                                        GENERIC_VALUE_DOUBLE );
  addSetting( "turn_with_ball_freeze_thr" , &dTurnWithBallFreezeThr,
                                                        GENERIC_VALUE_DOUBLE );
  addSetting( "initial_formation"  , &iInitialFormation,GENERIC_VALUE_INTEGER);
  addSetting( "max_y_percentage"   , &dMaxYPercentage,  GENERIC_VALUE_DOUBLE );

}

/*! This method returns the confidence threshold below which player information
    is assumed illegal
   \return player confidence threshold */
double PlayerSettings::getPlayerConfThr( ) const
{
  return dPlayerConfThr;
}

/*! This method sets the confidence threshold below which player information is
    assumed illegal
    \param d player confidence threshold in range [0..1]
    \return boolean indicating whether update was successful */
bool PlayerSettings::setPlayerConfThr( double d )
{
  dPlayerConfThr = d;
  return true;
}

/*! This method returns the confidence threshold above which player information
    is assumed very good.
    \return player high confidence threshold */
double PlayerSettings::getPlayerHighConfThr( ) const
{
  return dPlayerHighConfThr;
}

/*! This method sets the confidence threshold above which player information is
    assumed very good
    \param d player high confidence threshold in range [0..1]
    \return boolean indicating whether update was successful */
bool PlayerSettings::setPlayerHighConfThr( double d )
{
  dPlayerHighConfThr = d;
  return true;
}

/*! This method returns the confidence threshold below which ball information
    is assumed illegal.
    \return ball confidence threshold */
double PlayerSettings::getBallConfThr( ) const
{
  return dBallConfThr;
}

/*! This method sets the confidence threshold below which ball information is
    assumed illegal
    \param d ball confidence threshold in range [0..1]
    \return boolean indicating whether update was successful */
bool PlayerSettings::setBallConfThr( double d )
{
  dBallConfThr = d;
  return true;
}

/*! This method returns the radius in which a player has to be to be
    mapped from unknown to known player
    \return radius in which player is assumed same player. */
double PlayerSettings::getPlayerDistTolerance( ) const
{
  return dPlayerDistTolerance;
}

/*! This method sets the radius in which a player has to be to be
    mapped from unknown to known player
    \param d radius (>0) in which player is assumed same player
    \return boolean indicating whether update was successful */
bool PlayerSettings::setPlayerDistTolerance( double d )
{
  dPlayerDistTolerance = d;
  return true;
}

/*!This method returns the angle when a player determines to turn to a point
   first before moving towards it.
   \return global angle when player first moves before moving towards point*/
double PlayerSettings::getPlayerWhenToTurnAngle( ) const
{
  return dPlayerWhenToTurnAngle;
}

/*! This method sets the angle when a player determines to turn to a point
    first before moving towards it.
    \param d global angle when player turns in move (interval [0..360]).
    \return boolean indicating whether update was successful */
bool PlayerSettings::setPlayerWhenToTurnAngle( double d )
{
  dPlayerWhenToTurnAngle = d;
  return true;
}

/*! This method returns the percentage of the maximal acceleration in which
    case a kick should still be performed. This value
    is needed to determine whether the ball should be better positioned or
    should be kicked when the ball should be kicked hard.
    If it is possible to accelerate the ball with a higher
    percentage than the returned percentage the kick is performed, in all other
    cases the ball is positioned better.
    \return percentage of ball acceleration when kick should be performed */
double PlayerSettings::getPlayerWhenToKick( ) const
{
  return dPlayerWhenToKick;
}

/*! This method sets the percentage of the maximal acceleration that defines
    in which cases the ball is actually kicked or in which case it is
    positioned better when the ball should be given a very high velocity.
    \param d percentage in range [0..1]
    \return boolean indicating whether update was successful */
bool PlayerSettings::setPlayerWhenToKick( double d )
{
  dPlayerWhenToKick = d;
  return true;
}

/*! This method returns the maximal allowed number of cycles to intercept the
    ball. If it takes more cycles to intercept the ball, the ball is not
    intercepted.
    \return number of intercept cycles */
int PlayerSettings::getPlayerWhenToIntercept( ) const
{
  return iPlayerWhenToIntercept;
}

/*! This methods sets the maximal allowed number of cycles to intercept the
    ball.
    \param i new maximal allowed number of cycles (>0)
    \return boolean indicating whether update was successful */
bool PlayerSettings::setPlayerWhenToIntercept( int i )
{
  iPlayerWhenToIntercept = i;
  return true;
}

/*! This method returns the clear ball distance. When a clear ball is
    performed, the ball is aimed to a point just in front of the penalty area
    of the opponent. This method returns the distance before the penalty area
    to which the ball is aimed.
    \return clear ball distance before opponent penalty area */
double PlayerSettings::getClearBallDist( ) const
{
  return dClearBallDist;
}


/*! This method sets the clear ball distance.
    \param d new clear ball distance before opponent penalty area (>0).
    \return boolean indicating whether update was successful */
bool PlayerSettings::setClearBallDist( double d )
{
  dClearBallDist = d;
  return true;
}

/*! This method returns the distance in which opponents are taken into account
    when a clear ball is issued.
    \return maximum opponent distance for clear ball. */
double PlayerSettings::getClearBallOppMaxDist( ) const
{
  return dClearBallOppMaxDist;
}

/*! This method sets the distance in which opponents are taken into account
    when a clear ball is issued.
    \param d maximum opponent distance for clear ball (>0).
    \return boolean indicating whether update was successful */
bool PlayerSettings::setClearBallOppMaxDist( double d )
{
  dClearBallOppMaxDist = d;
  return true;
}

/*! This method returns the minimum needed angle for a clear ball to the side.
    \return minimum needed angle for clear ball to side */
double PlayerSettings::getClearBallToSideAngle( ) const
{
  return dClearBallToSideAngle;
}

/*! This method sets the minimum needed angle for a clear ball to the side.
    \param d minimum needed angle (>0) for clear ball to side
    \return boolean indicating whether update was successful */
bool PlayerSettings::setClearBallToSideAngle( double d )
{
  dClearBallToSideAngle = d;
  return true;
}

/*! This method returns the cone width that is used to check for opponents when
    passing to a player. A pass is only performed when no opponents are in the
    cone. The cone is specified as the width to one side
    after distance 1. So for a value of 0.5 the cone angle equals
    45 (22.5 to both sides).
    \return cone width in which no opponents are allowed when passing */
double PlayerSettings::getConeWidth( ) const
{
  return dConeWidth;
}

/*! This method sets the cone width in which no opponents are allowed when the
    ball is passed to a teammate. The cone width is specified as the width to
    one side after distance 1. So for a value of 0.5 the cone angle
    equals 45 (22.5 to both sides).
    \param d cone width in which no opponents are allowed when passing (>0)