---

ServerSettings.cpp

Go to the documentation of this file.

/*
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.
*/

#include "ServerSettings.h"
#include <stdio.h>
#include <string.h>           // needed for 'strcpy'

/*****************************************************************************/
/*******************   CLASS SERVERSETTINGS   ********************************/
/*****************************************************************************/

ServerSettings::ServerSettings( ):GenericValues( "ServerSettings", 121 )
{
  // goal-related parameters
  dGoalWidth         = 14.02; // goal_width: the width of the goal

  // player-related parameters
  dPlayerSize        = 0.3;   // player_size: the size (=radius) of a player
  dPlayerDecay       = 0.4;   // player_decay: player speed decay per cycle
  dPlayerRand        = 0.1;   // player_rand: random error in player movement
  dPlayerWeight      = 60.0;  // player_weight: weight of a player (for wind)
  dPlayerSpeedMax    = 1.2;   // player_speed_max: maximum speed of a player
  dPlayerAccelMax    = 1.0;   // player_accel_max: maximum acceleration of a
                              // player per cycle

  // stamina-related parameters
  dStaminaMax        = 4000.0;// stamina_max: maximum stamina of a player
  dStaminaIncMax     = 45.0;  // stamina_inc_max: maximum stamina increase of a
                              // player per cycle
  dRecoverDecThr     = 0.3;   // recover_dec_thr: percentage of stamina_max
                              // below which player recovery decreases
  dRecoverDec        = 0.002; // recover_dec: decrement step per cycle for
                              // player recovery
  dRecoverMin        = 0.5;   // recover_min: minimum player recovery
  dEffortDecThr      = 0.3;   // effort_dec_thr: % of stamina_max below
                              // which player effort capacity decreases
  dEffortDec         = 0.005; // effort_dec: decrement step per cycle for
                              // player effort capacity
  dEffortIncThr      = 0.6;   // effort_incr_thr: percentage of stamina_max
                              // above which player effort capacity increases
  dEffortInc         = 0.01;  // effort_inc: increment step per cycle for
                              // player effort capacity
  dEffortMin         = 0.6;   // effort_min: minimum value for player effort

  // parameters related to auditory perception
  iHearMax           = 2;     // hear_max: max hearing capacity of a player;
                              // a player can hear hear_inc messages in
                              // hear_decay simulation cycles
  iHearInc           = 1;     // hear_inc: min hearing capacity of a player,
                              // i.e. the number of messages a player can hear
                              // in hear_decay simulation cycles
  iHearDecay         = 2;     // hear_decay: decay rate of player hearing
                              // capacity, i.e. minimum number of cycles for
                              // hear_inc messages

  // parameters related to player turn actions
  dInertiaMoment     = 5.0;   // inertia_moment: inertia moment of a player;
                              // affects actual turn angle depending on speed

  // parameters related to sense_body information
  iSenseBodyStep     = 100;   // sense_body_step: length of the interval (ms)
                              // between sense_body information messages

  // goalkeeper-related parameters
  dCatchableAreaL    = 2.0;   // catchable_area_l: length of area around
                              // goalkeeper in which he can catch the ball
  dCatchableAreaW    = 1.0;   // catchable_area_w: width of area around
                              // goalkeeper in which he can catch the ball
  dCatchProbability  = 1.0;   // catch_probability: the probability for a
                              // goalkeeper to catch the ball
  iCatchBanCycle     = 5 ;    // catch_ban_cycle: number of cycles after catch
                              // in which goalkeeper cannot catch again
  iGoalieMaxMoves    = 2;     // goalie_max_moves: maximum number of 'move'
                              // actions allowed for goalkeeper after catch

  // ball-related parameters
  dBallSize          = 0.085; // ball_size: the size (=radius) of the ball
  dBallDecay         = 0.94;  // ball_decay: ball speed decay per cycle
  dBallRand          = 0.05;  // ball_rand: random error in ball movement
  dBallWeight        = 0.2;   // ball_weight: weight of the ball (for wind)
  dBallSpeedMax      = 2.7;   // ball_speed_max: maximum speed of the ball
  dBallAccelMax      = 2.7;   // ball_accel_max: maximum acceleration of the
                              // ball per cycle

  // wind-related parameters
  dWindForce         = 0.0;   // wind_force: the force of the wind
  dWindDir           = 0.0;   // wind_dir: the direction of the wind
  dWindRand          = 0.0;   // wind_rand: random error in wind direction
  bWindRandom        = false; // wind_random: is wind force and dir random

  // parameters related to 'dash' and 'kick' commands
  dKickableMargin    = 0.7;   // kickable_margin: margin around player in which
                              // ball is kickable; kickable area thus equals
                              // kickable_margin + ball_size + player_size
  dCkickMargin       = 1.0;   // ckick_margin: corner kick margin, i.e. the
                              // minimum distance to the ball for offending
                              // players when a corner kick is taken

  dDashPowerRate     = 0.006; // dash_power_rate: rate by which the 'Power'
                              // argument in a 'dash' command is multiplied
                              // (thus determining the amount of displacement
                              // of the player as a result of the 'dash')
  dKickPowerRate     = 0.027; // kick_power_rate: rate by which the 'Power'
                              // argument in a 'kick' command is multiplied
                              // (thus determining the amount of displacement 
                              // of the ball as a result of the 'kick')
  dKickRand          = 0.0;   // kick_rand: random error in kick direction

  // parameters related to visual and auditory perception range
  dVisibleAngle      = 90.0;  // visible_angle: angle of the view cone of a
                              // player in the standard view mode
  dAudioCutDist      = 50.0;  // audio_cut_dist: maximum distance over which a
                              // spoken message can be heard

  // quantization parameters
  dQuantizeStep      = 0.1;   // quantize_step: quantization step for distance
                              // of moving objects
  dQuantizeStepL     = 0.01;  // quantize_step_l: quantization step for dist
                              // of landmarks

  // range parameters for basic actuator commands
  iMaxPower          = 100;   // maxpower: maximum power for dash/kick
  iMinPower          = -100;  // minpower: minimum power for dash/kick
  iMaxMoment         = 180;   // maxmoment: maximum angle for turn/kick
  iMinMoment         = -180;  // minmoment: minimum angle for turn/kick
  iMaxNeckMoment     = 180;   // maxneckmoment: maximum angle for turnneck
  iMinNeckMoment     = -180;  // minneckmoment: minimum angle for turnneck
  iMaxNeckAng        = 90;    // maxneckang: maximum neck angle rel to body
  iMinNeckAng        = -90;   // minneckang: minimum neck angle rel to body

  // port-related parameters
  iPort              = 6000;  // port: port number for player connection
  iCoachPort         = 6001;  // coach_port: port number for coach connection
  iOlCoachPort       = 6002;  // ol_coach_port: port number for online coach

  // coach-related parameters
  iSayCoachCntMax    = 128;   // say_coach_cnt_max: maximum number of coach
                              // messages possible
  iSayCoachMsgSize   = 128;   // say_coach_msg_size: maximum size of coach
                              // messages
  iClangWinSize      = 300;   // clang_win_size: time window which controls how
                              // many coach messages can be sent
  iClangDefineWin    = 1;     // clang_define_win: number of define messages by
                              // coach per time window
  iClangMetaWin      = 1;     // clang_meta_win: number of meta messages by
                              // coach per time window
  iClangAdviceWin    = 1;     // clang_advice_win: number of advice messages by
                              // coach per time window
  iClangInfoWin      = 1;     // clang_info_win: number of info messages by
                              // coach per time window
  iClangMessDelay    = 50;    // clang_mess_delay: delay of coach messages, ie
                              // the number of cycles between send to player 
                              // and receival of message
  iClangMessPerCycle = 1;     // clang_mess_per_cycle: number of coach messages
                              // per cycle
  iSendViStep        = 100;   // send_vi_step: interval of coach's look, i.e.
                              // the length of the interval (in ms) between
                              // visual messages to the coach

  // time-related parameters
  iSimulatorStep     = 100;   // simulator_step: the length (in ms) of a
                              // simulator cycle
  iSendStep          = 150;   // send_step: the length of the interval (in ms)
                              // between visual messages to a player in the
                              // standard view mode
  iRecvStep          = 10;    // recv_step: the length of the interval (in ms)
                              // for accepting commands from a player
  iHalfTime          = 300;   // half_time: the length (in seconds) of a single
                              // game half
  iDropBallTime      = 200;   // drop_ball_time: the number of cycles to wait
                              // until dropping the ball automatically for free
                              // kicks, corner kicks, etc.

  // speech-related parameters
  iSayMsgSize        = 512;   // say_msg_size: the maximum length (in bytes) of
                              // a spoken message

  // offside-related parameters
  bUseOffside            = true; // use_offside: a boolean flag indicating
                                 // whether the offside rule should be applied
                                 // or not
  dOffsideActiveAreaSize = 5.0;  // offside_active_area_size: offside active
                                 // area size, i.e. radius of circle around
                                 // the ball in which player can be offside
  bForbidKickOffOffside  = true; // forbid_kick_off_offside: a boolean flag
                                 // indicating whether a kick from offside
                                 // position is allowed
  dOffsideKickMargin     = 9.15; // offside_kick_margin: offside kick margin
                                 // i.e. the minimum distance to the ball for
                                 // offending players when a free kick for
                                 // offside is taken

  // log-related parameters
  bVerbose           = false; // verbose: flag indicating whether verbose mode
                              // is active or not; in verbose mode server sends
                              // extra error-information
  iRecordVersion     = 3;     // record_version: the type of log record
  bRecordLog         = true;  // record_log: flag indicating whether log record
                              // for game should be created
  bSendLog           = true;  // send_log: flag indicating whether send client
                              // command log for game should be created
  bLogTimes          = false; // log_times: flag indicating whether ms should 
                              // be written between cycles in log file
  strcpy( strLogFile, "server.log" );// server log to store all actions receiv
  bSynchMode         = false; // synch_mode: in synchronization mode?
  bFullStateL        = false; // fullstate_l, full information left team
  bFullStateR        = false; // fulstate_r, full information right team
  
  // heterogeneous player parameters from player.conf
  iPlayerTypes              = 7;     // player_types: the number of player type
                                     // including the default player type
  iSubsMax                  = 3;     // subs_max: the maximum number of
                                     // substitutions allowed during a game the
                                     // value also indicates the maximum number
                                     // of players allowed for each type
  dPlayerSpeedMaxDeltaMin   = 0.0;   // player_speed_max_delta_min: minimum
                                     // delta for adjusting player_speed_max
  dPlayerSpeedMaxDeltaMax   = 0.0;   // player_speed_max_delta_max: maximum
                                     // delta for adjusting player_speed_max
  dStaminaIncMaxDeltaFactor = 0.0;   // stamina_inc_max_delta_factor: amount by
                                     // which delta is multiplied for
                                     // stamina_inc_max
  dPlayerDecayDeltaMin      = 0.0;   // player_decay_delta_min: minimum delta
                                     // for adjusting player_decay
  dPlayerDecayDeltaMax      = 0.2;   // player_decay_delta_max: maximum delta
                                     // for adjusting player_decay
  dInertiaMomentDeltaFactor = 25.0;  // inertia_moment_delta_factor: amount by
                                     // which delta is multiplied for
                                     // inertia_moment
  dDashPowerRateDeltaMin    = 0.0;   // dash_power_rate_delta_min: min delta
                                     // for adjusting dash_power_rate
  dDashPowerRateDeltaMax    = 0.0;   // dash_power_rate_delta_max: max delta
                                     // for adjusting dash_power_rate
  dPlayerSizeDeltaFactor    = -100.0;// player_size_delta_factor: amount delta
                                     // is multiplied by for player_size
  dKickableMarginDeltaMin   = 0.0;   // kickable_margin_delta_min: min delta
                                     // for adjusting kickable_margin
  dKickableMarginDeltaMax   = 0.2;   // kickable_margin_delta_max: max delta
                                     // for adjusting kickable_margin
  dKickRandDeltaFactor      = 0.5;   // kick_rand_delta_factor: amount delta is
                                     // multiplied by for kick_rand
  dExtraStaminaDeltaMin     = 0.0;   // extra_stamina_delta_min: minimum delta
                                     // for adjusting extra_stamina
  dExtraStaminaDeltaMax     = 100.0; // extra_stamina_delta_max: maximum delta
                                     // for adjusting extra_stamina
  dEffortMaxDeltaFactor     = -0.002;// effort_max_delta_factor: amount delta 
                                     // is multiplied by for effort_max
  dEffortMinDeltaFactor     = -0.002;// effort_min_delta_factor: amount delta
                                     // is multiplied by for effort_min
  dNewDashPowerRateDeltaMin = 0.0;   // dash_power_rate_delta_min: minimum 
                                     // delta for adjusting dash_power_rate
  dNewDashPowerRateDeltaMax = 0.002; // dash_power_rate_delta_max: maximum 
                                     // delta for adjusting dash_power_rate
  dNewStaminaIncMaxDeltaFactor=-100000.0;// stamina_inc_max_delta_factor: 
                               // amount by which delta is multiplied for
                                     // stamina_inc_max

  // important server parameters not in server.conf or player.conf
  dEffortMax         = 1.0; // effort_max: maximum player effort capacity
  iSlowDownFactor    = 1;   // slow_down_factor: factor to slow down simulator
                            // and send intervals
  dVisibleDistance   = 3.0; // visible_distance: distance within which objects
                            // are always 'visible' even when not in view cone)
  dExtraStamina      = 0.0; // extra_stamina: extra stamina for heterogeneous
                            // player

  // penalty parameters
  dPenDistX          = 11.0;         // pen_dist_x: distance ball from goal
  dPenMaxGoalieDistX = 4.0;          // pen_goalie_max_dist_x: maximum distance
                                     // for goalie during penalties
  bPenAllowMultKicks = false;        // pen_allow_mult_kicks: can penalty 
                                     // kicker kick multiple times

  // tackle parameters
  dTackleDist        = 2.0;          // tackle_dist: allowed distance in front 
  dTackleBackDist    = 0.5;          // tackle_back_dist: allowed distance back
  dTackleWidth       = 1.0;          // tackle_width: allowed distance side
  dTackleExponent    = 6;            // tackle_exponent: exponent need 
  iTackleCycles      = 10;           // tackle_cycles: cycles immobile 
  dTacklePowerRate   = 0.027;        // tackle_power_rate: power rate tackle

  // parameters which depend on other values
  dMaximalKickDist = dKickableMargin +   // the maximum distance from a player
                     dPlayerSize +       // for which the ball is kickable
                     dBallSize;

  // add all the settings, i.e. each parameter
  // becomes a new generic value for the class

  // goal-related parameters
  addSetting( "goal_width"        , &dGoalWidth       , GENERIC_VALUE_DOUBLE );

  // player-related parameters
  addSetting( "player_size"       , &dPlayerSize      , GENERIC_VALUE_DOUBLE );
  addSetting( "player_decay"      , &dPlayerDecay     , GENERIC_VALUE_DOUBLE );
  addSetting( "player_rand"       , &dPlayerRand      , GENERIC_VALUE_DOUBLE );
  addSetting( "player_weight"     , &dPlayerWeight    , GENERIC_VALUE_DOUBLE );
  addSetting( "player_speed_max"  , &dPlayerSpeedMax  , GENERIC_VALUE_DOUBLE );
  addSetting( "player_accel_max"  , &dPlayerAccelMax  , GENERIC_VALUE_DOUBLE );

  // stamina-related parameters
  addSetting( "stamina_max"       , &dStaminaMax      , GENERIC_VALUE_DOUBLE );
  addSetting( "stamina_inc_max"   , &dStaminaIncMax   , GENERIC_VALUE_DOUBLE );
  addSetting( "recover_dec_thr"   , &dRecoverDecThr   , GENERIC_VALUE_DOUBLE );
  addSetting( "recover_dec"       , &dRecoverDec      , GENERIC_VALUE_DOUBLE );
  addSetting( "recover_min"       , &dRecoverMin      , GENERIC_VALUE_DOUBLE );
  addSetting( "effort_dec_thr"    , &dEffortDecThr    , GENERIC_VALUE_DOUBLE );
  addSetting( "effort_dec"        , &dEffortDec       , GENERIC_VALUE_DOUBLE );
  addSetting( "effort_inc_thr"    , &dEffortIncThr    , GENERIC_VALUE_DOUBLE );
  addSetting( "effort_inc"        , &dEffortInc       , GENERIC_VALUE_DOUBLE );
  addSetting( "effort_min"        , &dEffortMin       , GENERIC_VALUE_DOUBLE );

  // parameters related to auditory perception
  addSetting( "hear_max"          , &iHearMax         , GENERIC_VALUE_INTEGER);
  addSetting( "hear_inc"          , &iHearInc         , GENERIC_VALUE_INTEGER);
  addSetting( "hear_decay"        , &iHearDecay       , GENERIC_VALUE_INTEGER);

  // parameters related to player turn actions
  addSetting( "inertia_moment"    , &dInertiaMoment   , GENERIC_VALUE_DOUBLE );

  // parameters related to sense_body information
  addSetting( "sense_body_step"   , &iSenseBodyStep   , GENERIC_VALUE_INTEGER);

  // goalkeeper-related parameters
  addSetting( "catchable_area_l"  , &dCatchableAreaL  , GENERIC_VALUE_DOUBLE );
  addSetting( "catchable_area_w"  , &dCatchableAreaW  , GENERIC_VALUE_DOUBLE );
  addSetting( "catch_probability" , &dCatchProbability, GENERIC_VALUE_DOUBLE );
  addSetting( "catch_ban_cycle"   , &iCatchBanCycle   , GENERIC_VALUE_INTEGER);
  addSetting( "goalie_max_moves"  , &iGoalieMaxMoves  , GENERIC_VALUE_INTEGER);

  // ball-related parameters
  addSetting( "ball_size"         , &dBallSize        , GENERIC_VALUE_DOUBLE );
  addSetting( "ball_decay"        , &dBallDecay       , GENERIC_VALUE_DOUBLE );
  addSetting( "ball_rand"         , &dBallRand        , GENERIC_VALUE_DOUBLE );
  addSetting( "ball_weight"       , &dBallWeight      , GENERIC_VALUE_DOUBLE );
  addSetting( "ball_speed_max"    , &dBallSpeedMax    , GENERIC_VALUE_DOUBLE );
  addSetting( "ball_accel_max"    , &dBallAccelMax    , GENERIC_VALUE_DOUBLE );

  // wind-related parameters
  addSetting( "wind_force"        , &dWindForce       , GENERIC_VALUE_DOUBLE );
  addSetting( "wind_dir"          , &dWindDir         , GENERIC_VALUE_DOUBLE );
  addSetting( "wind_rand"         , &dWindRand        , GENERIC_VALUE_DOUBLE );
  addSetting( "wind_random"       , &bWindRandom      , GENERIC_VALUE_BOOLEAN);
  // parameters related to 'dash' and 'kick' commands
  addSetting( "kickable_margin"   , &dKickableMargin  , GENERIC_VALUE_DOUBLE );
  addSetting( "ckick_margin"      , &dCkickMargin     , GENERIC_VALUE_DOUBLE );
  addSetting( "dash_power_rate"   , &dDashPowerRate   , GENERIC_VALUE_DOUBLE );
  addSetting( "kick_power_rate"   , &dKickPowerRate   , GENERIC_VALUE_DOUBLE );
  addSetting( "kick_rand"         , &dKickRand        , GENERIC_VALUE_DOUBLE );

  // parameters related to visual and auditory perception range
  addSetting( "visible_angle"     , &dVisibleAngle    , GENERIC_VALUE_DOUBLE );
  addSetting( "audio_cut_dist"    , &dAudioCutDist    , GENERIC_VALUE_DOUBLE );

  // quantization parameters
  addSetting( "quantize_step"     , &dQuantizeStep    , GENERIC_VALUE_DOUBLE );
  addSetting( "quantize_step_l"   , &dQuantizeStepL   , GENERIC_VALUE_DOUBLE );

  // range parameters for basic actuator commands
  addSetting( "maxpower"          , &iMaxPower        , GENERIC_VALUE_INTEGER);
  addSetting( "minpower"          , &iMinPower        , GENERIC_VALUE_INTEGER);
  addSetting( "maxmoment"         , &iMaxMoment       , GENERIC_VALUE_INTEGER);
  addSetting( "minmoment"         , &iMinMoment       , GENERIC_VALUE_INTEGER);
  addSetting( "maxneckmoment"     , &iMaxNeckMoment   , GENERIC_VALUE_INTEGER);
  addSetting( "minneckmoment"     , &iMinNeckMoment   , GENERIC_VALUE_INTEGER);
  addSetting( "maxneckang"        , &iMaxNeckAng      , GENERIC_VALUE_INTEGER);
  addSetting( "minneckang"        , &iMinNeckAng      , GENERIC_VALUE_INTEGER);

  // port-related parameters
  addSetting( "port"              , &iPort            , GENERIC_VALUE_INTEGER);
  addSetting( "coach_port"        , &iCoachPort       , GENERIC_VALUE_INTEGER);
  addSetting( "ol_coach_port"     , &iOlCoachPort     , GENERIC_VALUE_INTEGER);

  // coach-related parameters
  addSetting( "say_coach_cnt_max" , &iSayCoachCntMax  , GENERIC_VALUE_INTEGER);
  addSetting( "say_coach_msg_size", &iSayCoachMsgSize , GENERIC_VALUE_INTEGER);
  addSetting( "clang_win_size"    , &iClangWinSize    , GENERIC_VALUE_INTEGER);
  addSetting( "clang_define_win"  , &iClangDefineWin  , GENERIC_VALUE_INTEGER);
  addSetting( "clang_meta_win"    , &iClangMetaWin    , GENERIC_VALUE_INTEGER);
  addSetting( "clang_advice_win"  , &iClangAdviceWin  , GENERIC_VALUE_INTEGER);
  addSetting( "clang_info_win"    , &iClangInfoWin    , GENERIC_VALUE_INTEGER);
  addSetting( "clang_mess_delay"  , &iClangMessDelay  , GENERIC_VALUE_INTEGER);
  addSetting("clang_mess_per_cycle",&iClangMessPerCycle,GENERIC_VALUE_INTEGER);
  addSetting( "send_vi_step"      , &iSendViStep      , GENERIC_VALUE_INTEGER);

  // time-related parameters
  addSetting( "simulator_step"    , &iSimulatorStep   , GENERIC_VALUE_INTEGER);
  addSetting( "send_step"         , &iSendStep        , GENERIC_VALUE_INTEGER);
  addSetting( "recv_step"         , &iRecvStep        , GENERIC_VALUE_INTEGER);
  addSetting( "half_time"         , &iHalfTime        , GENERIC_VALUE_INTEGER);
  addSetting( "drop_ball_time"    , &iDropBallTime    , GENERIC_VALUE_INTEGER);

  // speech-related parameters
  addSetting( "say_msg_size"      , &iSayMsgSize      , GENERIC_VALUE_INTEGER);

  // offside-related parameters
  addSetting( "use_offside"       , &bUseOffside      , GENERIC_VALUE_BOOLEAN);
  addSetting( "offside_active_area_size", &dOffsideActiveAreaSize,
                                                        GENERIC_VALUE_DOUBLE );
  addSetting( "forbid_kick_off_offside" , &bForbidKickOffOffside ,
                                                        GENERIC_VALUE_BOOLEAN);
  addSetting( "offside_kick_margin",&dOffsideKickMargin,GENERIC_VALUE_DOUBLE );

  // log-related parameters
  addSetting( "verbose"           , &bVerbose         , GENERIC_VALUE_BOOLEAN);
  addSetting( "record_version"    , &iRecordVersion   , GENERIC_VALUE_INTEGER);
  addSetting( "record_log"        , &bRecordLog       , GENERIC_VALUE_BOOLEAN);
  addSetting( "send_log"          , &bSendLog         , GENERIC_VALUE_BOOLEAN);
  addSetting( "log_times"         , &bLogTimes        , GENERIC_VALUE_BOOLEAN);
  addSetting( "log_file"          , &strLogFile       , GENERIC_VALUE_STRING );
  addSetting( "synch_mode"        , &bSynchMode       , GENERIC_VALUE_BOOLEAN);
  addSetting( "fullstate_l"       , &bFullStateL      , GENERIC_VALUE_BOOLEAN);
  addSetting( "fullstate_r"       , &bFullStateR      , GENERIC_VALUE_BOOLEAN);
 
  // heterogeneous player parameters from player.conf
  addSetting( "player_types"      , &iPlayerTypes     , GENERIC_VALUE_INTEGER);
  addSetting( "subs_max"          , &iSubsMax         , GENERIC_VALUE_INTEGER);
  addSetting( "player_speed_max_delta_min"  , &dPlayerSpeedMaxDeltaMin  ,
                                                        GENERIC_VALUE_DOUBLE );
  addSetting( "player_speed_max_delta_max"  , &dPlayerSpeedMaxDeltaMax  ,
                                                        GENERIC_VALUE_DOUBLE );
  addSetting( "stamina_inc_max_delta_factor", &dStaminaIncMaxDeltaFactor,
                                                        GENERIC_VALUE_DOUBLE );
  addSetting( "player_decay_delta_min"      , &dPlayerDecayDeltaMin     ,
                                                        GENERIC_VALUE_DOUBLE );
  addSetting( "player_decay_delta_max"      , &dPlayerDecayDeltaMax     ,
                                                        GENERIC_VALUE_DOUBLE );
  addSetting( "inertia_moment_delta_factor" , &dInertiaMomentDeltaFactor,
                                                        GENERIC_VALUE_DOUBLE );
  addSetting( "dash_power_rate_delta_min"   , &dDashPowerRateDeltaMin   ,
                                                        GENERIC_VALUE_DOUBLE );
  addSetting( "dash_power_rate_delta_max"   , &dDashPowerRateDeltaMax   ,
                                                        GENERIC_VALUE_DOUBLE );
  addSetting( "player_size_delta_factor"    , &dPlayerSizeDeltaFactor   ,
                                                        GENERIC_VALUE_DOUBLE );
  addSetting( "kickable_margin_delta_min"   , &dKickableMarginDeltaMin  ,
                                                        GENERIC_VALUE_DOUBLE );
  addSetting( "kickable_margin_delta_max"   , &dKickableMarginDeltaMax  ,
                                                        GENERIC_VALUE_DOUBLE );
  addSetting( "kick_rand_delta_factor"      , &dKickRandDeltaFactor     ,
                                                        GENERIC_VALUE_DOUBLE );
  addSetting( "extra_stamina_delta_min"     , &dExtraStaminaDeltaMin    ,
                                                        GENERIC_VALUE_DOUBLE );
  addSetting( "extra_stamina_delta_max"     , &dExtraStaminaDeltaMax    ,
                                                        GENERIC_VALUE_DOUBLE );
  addSetting( "effort_max_delta_factor"     , &dEffortMaxDeltaFactor    ,
                                                        GENERIC_VALUE_DOUBLE );
  addSetting( "effort_min_delta_factor"     , &dEffortMinDeltaFactor    ,
                                                        GENERIC_VALUE_DOUBLE );
  addSetting( "new_dash_power_rate_delta_min", &dNewDashPowerRateDeltaMin   ,
                                                        GENERIC_VALUE_DOUBLE );
  addSetting( "new_dash_power_rate_delta_max", &dNewDashPowerRateDeltaMax   ,
                                                        GENERIC_VALUE_DOUBLE );
  addSetting( "new_stamina_inc_max_delta_factor", &dNewStaminaIncMaxDeltaFactor
                                                      ,GENERIC_VALUE_DOUBLE  );
  
  // penalty parameters
  addSetting( "pen_dist_x"        , &dPenDistX        , GENERIC_VALUE_DOUBLE );
  addSetting("pen_goalie_max_dist_x",&dPenMaxGoalieDistX,GENERIC_VALUE_DOUBLE);
  addSetting("pen_allow_mult_kicks",&bPenAllowMultKicks,GENERIC_VALUE_BOOLEAN);

  // tackle parameters
  addSetting( "tackle_dist"       , &dTackleDist      , GENERIC_VALUE_DOUBLE );
  addSetting( "tackle_back_dist"  , &dTackleBackDist  , GENERIC_VALUE_DOUBLE );
  addSetting( "tackle_width"      , &dTackleWidth     , GENERIC_VALUE_DOUBLE );
  addSetting( "tackle_exponent"   , &dTackleExponent  , GENERIC_VALUE_DOUBLE );
  addSetting( "tackle_cycles"     , &iTackleCycles    , GENERIC_VALUE_INTEGER);
  addSetting( "tackle_power_rate" , &dTacklePowerRate , GENERIC_VALUE_DOUBLE );
 
  // important server parameters not in server.conf or player.conf - are now
  addSetting( "effort_max"        , &dEffortMax       , GENERIC_VALUE_DOUBLE );
  addSetting( "slow_down_factor"  , &iSlowDownFactor  , GENERIC_VALUE_INTEGER);
  addSetting( "visible_distance"  , &dVisibleDistance , GENERIC_VALUE_DOUBLE );
  addSetting( "extra_stamina"     , &dExtraStamina    , GENERIC_VALUE_DOUBLE );

  // parameters which depend on other values
  addSetting( "dMaximalKickDist"  , &dMaximalKickDist , GENERIC_VALUE_DOUBLE );
}

bool ServerSettings::setValue( const char *strName, const char *strValue )
{
  // call to the superclass method
  bool bReturn = GenericValues::setValue( strName, strValue );
  // compute values for parameters which depend on others (reason for override)
  dMaximalKickDist = ( dKickableMargin + dPlayerSize + dBallSize );

  return ( bReturn );
}

bool ServerSettings::readValues( const char *strFileName, 
                                 const char *strSeparator )
{
  // call to the superclass method
  bool bReturn = GenericValues::readValues( strFileName, strSeparator );
  // compute values for parameters which depend on others (reason for override)
  dMaximalKickDist = ( dKickableMargin + dPlayerSize + dBallSize );

  return ( bReturn );
}

bool ServerSettings::setGoalWidth( double d )
{
  dGoalWidth = d;
  return ( true );
}

double ServerSettings::getGoalWidth( ) const
{
  return ( dGoalWidth );
}

bool ServerSettings::setPlayerSize( double d )
{
  dPlayerSize = d;
  // NOTE: also update parameters for which the value depends on this variable
  dMaximalKickDist = ( dKickableMargin + dPlayerSize + dBallSize );

  return ( true );
}

double ServerSettings::getPlayerSize( ) const
{
  return ( dPlayerSize );
}

bool ServerSettings::setPlayerDecay( double d )
{
  dPlayerDecay = d;
  return ( true );
}

double ServerSettings::getPlayerDecay( ) const
{
  return ( dPlayerDecay );
}

bool ServerSettings::setPlayerRand( double d )
{
  dPlayerRand = d;
  return ( true );
}

double ServerSettings::getPlayerRand( ) const
{
  return ( dPlayerRand );
}

bool ServerSettings::setPlayerWeight( double d )
{
  dPlayerWeight = d;
  return ( true );
}

double ServerSettings::getPlayerWeight( ) const
{
  return ( dPlayerWeight );
}

bool ServerSettings::setPlayerSpeedMax( double d )
{
  dPlayerSpeedMax = d;
  return ( true );
}

double ServerSettings::getPlayerSpeedMax( ) const
{
  return ( dPlayerSpeedMax );
}

bool ServerSettings::setPlayerAccelMax( double d )
{
  dPlayerAccelMax = d;
  return ( true );
}

double ServerSettings::getPlayerAccelMax( ) const
{
  return ( dPlayerAccelMax );
}

bool ServerSettings::setStaminaMax( double d )
{
  dStaminaMax = d;
  return ( true );
}

double ServerSettings::getStaminaMax( ) const
{
  return ( dStaminaMax );
}

bool ServerSettings::setStaminaIncMax( double d )
{
  dStaminaIncMax = d;
  return ( true );
}

double ServerSettings::getStaminaIncMax( ) const
{
  return ( dStaminaIncMax );
}

bool ServerSettings::setRecoverDecThr( double d )
{
  dRecoverDecThr = d;
  return ( true );
}

double ServerSettings::getRecoverDecThr( ) const
{
  return ( dRecoverDecThr );
}

bool ServerSettings::setRecoverDec( double d )
{
  dRecoverDec = d;
  return ( true );
}

double ServerSettings::getRecoverDec( ) const
{
  return ( dRecoverDec );
}

bool ServerSettings::setRecoverMin( double d )
{
  dRecoverMin = d;
  return ( true );
}

double ServerSettings::getRecoverMin( ) const
{
  return ( dRecoverMin );
}

bool ServerSettings::setEffortDecThr( double d )
{
  dEffortDecThr = d;
  return ( true );
}

double ServerSettings::getEffortDecThr( ) const
{
  return ( dEffortDecThr );
}

bool ServerSettings::setEffortDec( double d )
{
  dEffortDec = d;
  return ( true );
}

double ServerSettings::getEffortDec( ) const
{
  return ( dEffortDec );
}

bool ServerSettings::setEffortIncThr( double d )
{
  dEffortIncThr = d;
  return ( true );
}

double ServerSettings::getEffortIncThr( ) const
{
  return ( dEffortIncThr );
}

bool ServerSettings::setEffortInc( double d )
{
  dEffortInc = d;
  return ( true );
}

double ServerSettings::getEffortInc( ) const
{
  return ( dEffortInc );
}

bool ServerSettings::setEffortMin( double d )
{
  dEffortMin = d;
  return ( true );
}

double ServerSettings::getEffortMin( ) const
{
  return ( dEffortMin );
}

bool ServerSettings::setHearMax( int i )
{
  iHearMax = i;
  return ( true );
}

int ServerSettings::getHearMax( ) const
{
  return ( iHearMax );
}

bool ServerSettings::setHearInc( int i )
{
  iHearInc = i;
  return ( true );
}

int ServerSettings::getHearInc( ) const
{
  return ( iHearInc );
}

bool ServerSettings::setHearDecay( int i )
{
  iHearDecay = i;
  return ( true );
}

int ServerSettings::getHearDecay( ) const
{
  return ( iHearDecay );
}

bool ServerSettings::setInertiaMoment( double d )
{
  dInertiaMoment = d;
  return ( true );
}

double ServerSettings::getInertiaMoment( ) const
{
  return ( dInertiaMoment );
}

bool ServerSettings::setSenseBodyStep( int i )
{
  iSenseBodyStep = i;
  return ( true );
}

int ServerSettings::getSenseBodyStep( ) const
{
  // NOTE: do not take slow down factor into account for send intervals
  // already done by server
  return iSenseBodyStep ; // * iSlowDownFactor );
}

bool ServerSettings::setCatchableAreaL( double d )
{
  dCatchableAreaL = d;
  return ( true );
}

double ServerSettings::getCatchableAreaL( ) const
{
  return ( dCatchableAreaL );
}

bool ServerSettings::setCatchableAreaW( double d )
{
  dCatchableAreaW = d;
  return ( true );
}

double ServerSettings::getCatchableAreaW( ) const
{
  return ( dCatchableAreaW );
}

bool ServerSettings::setCatchProbability( double d )
{
  dCatchProbability = d;
  return ( true );
}

double ServerSettings::getCatchProbability( ) const
{
  return ( dCatchProbability );
}

bool ServerSettings::setCatchBanCycle( int i )
{
  iCatchBanCycle = i;
  return ( true );
}

int ServerSettings::getCatchBanCycle( ) const
{
  return ( iCatchBanCycle );
}

bool ServerSettings::setGoalieMaxMoves( int i )
{
  iGoalieMaxMoves = i;
  return ( true );
}

int ServerSettings::getGoalieMaxMoves( ) const
{
  return ( iGoalieMaxMoves );
}

bool ServerSettings::setBallSize( double d )
{
  dBallSize = d;
  // NOTE: also update parameters for which the value depends on this variable
  dMaximalKickDist = ( dKickableMargin + dPlayerSize + dBallSize );

  return ( true );
}

double ServerSettings::getBallSize( ) const
{
  return ( dBallSize );
}

bool ServerSettings::setBallDecay( double d )
{
  dBallDecay = d;
  return ( true );
}

double ServerSettings::getBallDecay( ) const
{
  return ( dBallDecay );
}

bool ServerSettings::setBallRand( double d )
{
  dBallRand = d;
  return ( true );
}

double ServerSettings::getBallRand( ) const
{
  return ( dBallRand );
}

bool ServerSettings::setBallWeight( double d )
{
  dBallWeight = d;
  return ( true );
}

double ServerSettings::getBallWeight( ) const
{
  return ( dBallWeight );
}

bool ServerSettings::setBallSpeedMax( double d )
{
  dBallSpeedMax = d;
  return ( true );
}

double ServerSettings::getBallSpeedMax( ) const
{
  return ( dBallSpeedMax );
}

bool ServerSettings::setBallAccelMax( double d )
{
  dBallAccelMax = d;
  return ( true );
}

double ServerSettings::getBallAccelMax( ) const
{
  return ( dBallAccelMax );
}

bool ServerSettings::setWindForce( double d )
{
  dWindForce = d;
  return ( true );
}

double ServerSettings::getWindForce( ) const
{
  return ( dWindForce );
}

bool ServerSettings::setWindDir( double d )
{
  dWindDir = d;
  return ( true );
}

double ServerSettings::getWindDir( ) const
{
  return ( dWindDir );
}

bool ServerSettings::setWindRand( double d )
{
  dWindRand = d;
  return ( true );
}

double ServerSettings::getWindRand( ) const
{
  return ( dWindRand );
}

bool ServerSettings::setWindRandom( bool b )
{
  bWindRandom = b;
  return ( true );
}

bool ServerSettings::getWindRandom( ) const
{
  return bWindRandom;
}

bool ServerSettings::setKickableMargin( double d )
{
  dKickableMargin = d;
  // NOTE: also update parameters for which the value depends on this variable
  dMaximalKickDist = ( dKickableMargin + dPlayerSize + dBallSize );

  return ( true );
}

double ServerSettings::getKickableMargin( ) const
{
  return ( dKickableMargin );
}

bool ServerSettings::setCkickMargin( double d )
{
  dCkickMargin = d;
  return ( true );
}

double ServerSettings::getCkickMargin( ) const
{
  return ( dCkickMargin );
}

bool ServerSettings::setDashPowerRate( double d )
{
  dDashPowerRate = d;
  return ( true );
}

double ServerSettings::getDashPowerRate( ) const
{
  return ( dDashPowerRate );
}

bool ServerSettings::setKickPowerRate( double d )
{
  dKickPowerRate = d;
  return ( true );
}

double ServerSettings::getKickPowerRate( ) const
{
  return ( dKickPowerRate );
}

bool ServerSettings::setKickRand( double d )
{
  dKickRand = d;
  return ( true );
}

double ServerSettings::getKickRand( ) const
{
  return ( dKickRand );
}

bool ServerSettings::setVisibleAngle( double d )
{
  dVisibleAngle = d;
  return ( true );
}

double ServerSettings::getVisibleAngle( ) const
{
  return ( dVisibleAngle );
}

bool ServerSettings::setAudioCutDist( double d )
{
  dAudioCutDist = d;
  return ( true );
}

double ServerSettings::getAudioCutDist( ) const
{
  return ( dAudioCutDist );
}

bool ServerSettings::setQuantizeStep( double d )
{
  dQuantizeStep = d;
  return ( true );
}

double ServerSettings::getQuantizeStep( ) const
{
  return ( dQuantizeStep );
}

bool ServerSettings::setQuantizeStepL( double d )
{
  dQuantizeStepL = d;
  return ( true );
}

double ServerSettings::getQuantizeStepL( ) const
{
  return ( dQuantizeStepL );
}

bool ServerSettings::setMaxPower( int i )
{
  iMaxPower = i;
  return ( true );
}

int ServerSettings::getMaxPower( ) const
{
  return ( iMaxPower );
}

bool ServerSettings::setMinPower( int i )
{
  iMinPower = i;
  return ( true );
}

int ServerSettings::getMinPower( ) const
{
  return ( iMinPower );
}

bool ServerSettings::setMaxMoment( int i )
{
  iMaxMoment = i;
  return ( true );
}

int ServerSettings::getMaxMoment( ) const
{
  return ( iMaxMoment );
}

bool ServerSettings::setMinMoment( int i )
{
  iMinMoment = i;
  return ( true );
}

int ServerSettings::getMinMoment( ) const
{
  return ( iMinMoment );
}

bool ServerSettings::setMaxNeckMoment( int i )
{
  iMaxNeckMoment = i;
  return ( true );
}

int ServerSettings::getMaxNeckMoment( ) const
{
  return ( iMaxNeckMoment );
}

bool ServerSettings::setMinNeckMoment( int i )
{
  iMinNeckMoment = i;
  return ( true );
}

int ServerSettings::getMinNeckMoment( ) const
{
  return ( iMinNeckMoment );
}

bool ServerSettings::setMaxNeckAng( int i )
{
  iMaxNeckAng = i;
  return ( true );
}

int ServerSettings::getMaxNeckAng( ) const
{
  return ( iMaxNeckAng );
}

bool ServerSettings::setMinNeckAng( int i )
{
  iMinNeckAng = i;
  return ( true );
}

int ServerSettings::getMinNeckAng( ) const
{
  return ( iMinNeckAng );
}

bool ServerSettings::setPort( int i )
{
  iPort = i;
  return ( true );
}

int ServerSettings::getPort( ) const
{
  return ( iPort );
}

bool ServerSettings::setCoachPort( int i )
{
  iCoachPort = i;
  return ( true );
}

int ServerSettings::getCoachPort( ) const
{
  return ( iCoachPort );
}

bool ServerSettings::setOlCoachPort( int i )
{
  iOlCoachPort = i;
  return ( true );
}

int ServerSettings::getOlCoachPort( ) const
{
  return ( iOlCoachPort );
}

bool ServerSettings::setSayCoachCntMax( int i )
{
  iSayCoachCntMax = i;
  return ( true );
}

int ServerSettings::getSayCoachCntMax( ) const
{
  return ( iSayCoachCntMax );
}

bool ServerSettings::setSayCoachMsgSize( int i )
{
  iSayCoachMsgSize = i;
  return ( true );
}

int ServerSettings::getSayCoachMsgSize( ) const
{
  return ( iSayCoachMsgSize );
}

bool ServerSettings::setClangWinSize( int i )
{
  iClangWinSize = i;
  return ( true );
}

int ServerSettings::getClangWinSize( ) const
{
  return ( iClangWinSize );
}

bool ServerSettings::setClangDefineWin( int i )
{
  iClangDefineWin = i;
  return ( true );
}

int ServerSettings::getClangDefineWin( ) const
{
  return ( iClangDefineWin );
}

bool ServerSettings::setClangMetaWin( int i )
{
  iClangMetaWin = i;
  return ( true );
}

int ServerSettings::getClangMetaWin( ) const
{
  return ( iClangMetaWin );
}

bool ServerSettings::setClangAdviceWin( int i )
{
  iClangAdviceWin = i;
  return ( true );
}

int ServerSettings::getClangAdviceWin( ) const
{
  return ( iClangAdviceWin );
}

bool ServerSettings::setClangInfoWin( int i )
{
  iClangInfoWin = i;
  return ( true );
}

int ServerSettings::getClangInfoWin( ) const
{
  return ( iClangInfoWin );
}

bool ServerSettings::setClangMessDelay( int i )
{
  iClangMessDelay = i;
  return ( true );
}

int ServerSettings::getClangMessDelay( ) const
{
  return ( iClangMessDelay );
}

bool ServerSettings::setClangMessPerCycle( int i )
{
  iClangMessPerCycle = i;
  return ( true );
}

int ServerSettings::getClangMessPerCycle( ) const
{
  return ( iClangMessPerCycle );
}

bool ServerSettings::setSendViStep( int i )
{
  iSendViStep = i;
  return ( true );
}

int ServerSettings::getSendViStep( ) const
{
  // NOTE: do not take slow down factor into account for send intervals
  // already done by server
  return iSendViStep ; // * iSlowDownFactor );
}

bool ServerSettings::setSimulatorStep( int i )
{
  iSimulatorStep = i;
  return ( true );
}

int ServerSettings::getSimulatorStep( ) const
{
  // NOTE: do not take slow down factor into account for send intervals ->
  // already done in supplied server values
    return iSimulatorStep ; //  * iSlowDownFactor ;
}

bool ServerSettings::setSendStep( int i )
{
  iSendStep = i;
  return ( true );
}

int ServerSettings::getSendStep( ) const
{
  // NOTE: do not take slow down factor into account for send intervals,
  // already done by server
  return  iSendStep ; // * iSlowDownFactor );
}

bool ServerSettings::setRecvStep( int i )
{
  iRecvStep = i;
  return ( true );
}

int ServerSettings::getRecvStep( ) const
{
  return ( iRecvStep );
}

bool ServerSettings::setHalfTime( int i )
{
  iHalfTime = i;
  return ( true );
}

int ServerSettings::getHalfTime( ) const
{
  return ( iHalfTime );
}

bool ServerSettings::setDropBallTime( int i )
{
  iDropBallTime = i;
  return ( true );
}

int ServerSettings::getDropBallTime( ) const
{
  return ( iDropBallTime );
}

bool ServerSettings::setSayMsgSize( int i )
{
  iSayMsgSize = i;
  return ( true );
}

int ServerSettings::getSayMsgSize( ) const
{
  return ( iSayMsgSize );
}

bool ServerSettings::setUseOffside( bool b )
{
  bUseOffside = b;
  return ( true );
}

bool ServerSettings::getUseOffside( ) const
{
  return ( bUseOffside );
}

bool ServerSettings::setOffsideActiveAreaSize( double d )
{
  dOffsideActiveAreaSize = d;
  return ( true );
}

double ServerSettings::getOffsideActiveAreaSize( ) const
{
  return ( dOffsideActiveAreaSize );
}

bool ServerSettings::setForbidKickOffOffside( bool b )
{
  bForbidKickOffOffside = b;
  return ( true );
}

bool ServerSettings::getForbidKickOffOffside( ) const
{
  return ( bForbidKickOffOffside );
}

bool ServerSettings::setOffsideKickMargin( double d )
{
  dOffsideKickMargin = d;
  return ( true );
}

double ServerSettings::getOffsideKickMargin( ) const
{
  return ( dOffsideKickMargin );
}

bool ServerSettings::setVerbose( bool b )
{
  bVerbose = b;
  return ( true );
}

bool ServerSettings::getVerbose( ) const
{
  return ( bVerbose );
}

bool ServerSettings::setRecordVersion( int i )
{
  iRecordVersion = i;
  return ( true );
}

int ServerSettings::getRecordVersion( ) const
{
  return ( iRecordVersion );
}

bool ServerSettings::setRecordLog( bool b )
{
  bRecordLog = b;
  return ( true );
}

bool ServerSettings::getRecordLog( ) const
{
  return ( bRecordLog );
}

bool ServerSettings::setSendLog( bool b )
{
  bSendLog = b;
  return ( true );
}

bool ServerSettings::getSendLog( ) const
{
  return ( bSendLog );
}

bool ServerSettings::setLogTimes( bool b )
{
  bLogTimes = b;
  return ( true );
}

bool ServerSettings::getLogTimes( ) const
{
  return ( bLogTimes );
}

bool ServerSettings::setLogFile( char *str )
{
  strcpy( strLogFile, str );
  return ( true );
}

char* ServerSettings::getLogFile( )
{
  return ( strLogFile );
}

bool ServerSettings::setSynchMode( bool b )
{
  bSynchMode = b;
  return ( true );
}

bool ServerSettings::getSynchMode( ) const
{
  return ( bSynchMode );
}

bool ServerSettings::getFullStateRight( ) const
{  
  return bFullStateR;
}

bool ServerSettings::setFullStateRight( bool b ) 
{
  bFullStateR = b;
  return true; 
}

bool ServerSettings::setFullStateLeft( bool b ) 
{
  bFullStateL = b;
  return true; 
}

bool ServerSettings::getFullStateLeft( ) const
{  
  return bFullStateL;
}




bool ServerSettings::setPlayerTypes( int i )
{
  iPlayerTypes = i;
  return ( true );
}

int ServerSettings::getPlayerTypes( ) const
{
  return ( iPlayerTypes );
}

bool ServerSettings::setSubsMax( int i )
{
  iSubsMax = i;
  return ( true );
}

int ServerSettings::getSubsMax( ) const
{
  return ( iSubsMax );
}

bool ServerSettings::setPlayerSpeedMaxDeltaMin( double d )
{
  dPlayerSpeedMaxDeltaMin = d;
  return ( true );
}

double ServerSettings::getPlayerSpeedMaxDeltaMin( ) const
{
  return ( dPlayerSpeedMaxDeltaMin );
}

bool ServerSettings::setPlayerSpeedMaxDeltaMax( double d )
{
  dPlayerSpeedMaxDeltaMax = d;
  return ( true );
}

double ServerSettings::getPlayerSpeedMaxDeltaMax( ) const
{
  return ( dPlayerSpeedMaxDeltaMax );
}

bool ServerSettings::setStaminaIncMaxDeltaFactor( double d )
{
  dStaminaIncMaxDeltaFactor = d;
  return ( true );
}

double ServerSettings::getStaminaIncMaxDeltaFactor( ) const
{
  return ( dStaminaIncMaxDeltaFactor );
}

bool ServerSettings::setPlayerDecayDeltaMin( double d )
{
  dPlayerDecayDeltaMin = d;
  return ( true );
}

double ServerSettings::getPlayerDecayDeltaMin( ) const
{
  return ( dPlayerDecayDeltaMin );
}

bool ServerSettings::setPlayerDecayDeltaMax( double d )
{
  dPlayerDecayDeltaMax = d;
  return ( true );
}

double ServerSettings::getPlayerDecayDeltaMax( ) const
{
  return ( dPlayerDecayDeltaMax );
}

bool ServerSettings::setInertiaMomentDeltaFactor( double d )
{
  dInertiaMomentDeltaFactor = d;
  return ( true );
}

double ServerSettings::getInertiaMomentDeltaFactor( ) const
{
  return ( dInertiaMomentDeltaFactor );
}

bool ServerSettings::setDashPowerRateDeltaMin( double d )
{
  dDashPowerRateDeltaMin = d;
  return ( true );
}

double ServerSettings::getDashPowerRateDeltaMin( ) const
{
  return ( dDashPowerRateDeltaMin );
}

bool ServerSettings::setDashPowerRateDeltaMax( double d )
{
  dDashPowerRateDeltaMax = d;
  return ( true );
}

double ServerSettings::getDashPowerRateDeltaMax( ) const
{
  return ( dDashPowerRateDeltaMax );
}

bool ServerSettings::setPlayerSizeDeltaFactor( double d )
{
  dPlayerSizeDeltaFactor = d;
  return ( true );
}

double ServerSettings::getPlayerSizeDeltaFactor( ) const
{
  return ( dPlayerSizeDeltaFactor );
}

bool ServerSettings::setKickableMarginDeltaMin( double d )
{
  dKickableMarginDeltaMin = d;
  return ( true );
}

double ServerSettings::getKickableMarginDeltaMin( ) const
{
  return ( dKickableMarginDeltaMin );
}

bool ServerSettings::setKickableMarginDeltaMax( double d )
{
  dKickableMarginDeltaMax = d;
  return ( true );
}

double ServerSettings::getKickableMarginDeltaMax( ) const
{
  return ( dKickableMarginDeltaMax );
}

bool ServerSettings::setKickRandDeltaFactor( double d )
{
  dKickRandDeltaFactor = d;
  return ( true );
}

double ServerSettings::getKickRandDeltaFactor( ) const
{
  return ( dKickRandDeltaFactor );
}

bool ServerSettings::setExtraStaminaDeltaMin( double d )
{
  dExtraStaminaDeltaMin = d;
  return ( true );
}

double ServerSettings::getExtraStaminaDeltaMin( ) const
{
  return ( dExtraStaminaDeltaMin );
}

bool ServerSettings::setExtraStaminaDeltaMax( double d )
{
  dExtraStaminaDeltaMax = d;
  return ( true );
}

double ServerSettings::getExtraStaminaDeltaMax( ) const
{
  return ( dExtraStaminaDeltaMax );
}

bool ServerSettings::setEffortMaxDeltaFactor( double d )
{
  dEffortMaxDeltaFactor = d;
  return ( true );
}

double ServerSettings::getEffortMaxDeltaFactor( ) const
{
  return ( dEffortMaxDeltaFactor );
}

bool ServerSettings::setEffortMinDeltaFactor( double d )
{
  dEffortMinDeltaFactor = d;
  return ( true );
}

double ServerSettings::getEffortMinDeltaFactor( ) const
{
  return ( dEffortMinDeltaFactor );
}

bool ServerSettings::setNewDashPowerRateDeltaMin( double d )
{
  dNewDashPowerRateDeltaMin = d;
  return ( true );
}

double ServerSettings::getNewDashPowerRateDeltaMin( ) const
{
  return ( dNewDashPowerRateDeltaMin );
}

bool ServerSettings::setNewDashPowerRateDeltaMax( double d )
{
  dNewDashPowerRateDeltaMax = d;
  return ( true );
}

double ServerSettings::getNewDashPowerRateDeltaMax( ) const
{
  return ( dNewDashPowerRateDeltaMax );
}

bool ServerSettings::setNewStaminaIncMaxDeltaFactor( double d )
{
  dNewStaminaIncMaxDeltaFactor = d;
  return ( true );
}

double ServerSettings::getNewStaminaIncMaxDeltaFactor( ) const
{
  return ( dNewStaminaIncMaxDeltaFactor );
}

bool ServerSettings::setPenDistX( double d )
{
  dPenDistX = d;
  return true;
}

double ServerSettings::getPenDistX( ) const
{
  return dPenDistX;
}

bool ServerSettings::setPenMaxGoalieDistX( double d )
{
  dPenMaxGoalieDistX = d;
  return true;
}

double ServerSettings::getPenMaxGoalieDistX( ) const
{
  return dPenMaxGoalieDistX;
}

bool ServerSettings::setPenAllowMultKicks( bool b )
{
  bPenAllowMultKicks = b;
  return true;
}

bool ServerSettings::getPenAllowMultKicks( ) const
{
  return bPenAllowMultKicks;
}

bool ServerSettings::setTackleDist( double d )
{
  dTackleDist = d;
  return true;
}

double ServerSettings::getTackleDist( ) const
{
  return dTackleDist;
} 

bool ServerSettings::setTackleBackDist( double d )
{
  dTackleBackDist = d;
  return true;
}

double ServerSettings::getTackleBackDist( ) const
{
  return dTackleBackDist;
} 

bool ServerSettings::setTackleWidth( double d )
{
  dTackleWidth = d;
  return true;
}

double ServerSettings::getTackleWidth( ) const
{
  return dTackleWidth;
} 

bool ServerSettings::setTackleExponent( double d )
{
  dTackleExponent = d;
  return true;
}

double ServerSettings::getTackleExponent( ) const
{
  return dTackleExponent;
} 

bool ServerSettings::setTackleCycles( int i )
{
  iTackleCycles = i;
  return true;
}

int ServerSettings::getTackleCycles( ) const
{
  return iTackleCycles;
} 

bool ServerSettings::setTacklePowerRate( double d )
{
  dTacklePowerRate = d;
  return true;
}

double ServerSettings::getTacklePowerRate( ) const
{
  return dTacklePowerRate;
} 

bool ServerSettings::setEffortMax( double d )
{
  dEffortMax = d;
  return ( true );
}

double ServerSettings::getEffortMax(  ) const
{
  return ( dEffortMax );
}

bool ServerSettings::setSlowDownFactor( int i )
{
  iSlowDownFactor = i;
  return ( true );
}

int ServerSettings::getSlowDownFactor( ) const
{
  return ( iSlowDownFactor );
}

bool ServerSettings::setVisibleDistance( double d )
{
  dVisibleDistance = d;
  return ( true );
}

double ServerSettings::getVisibleDistance( ) const
{
  return ( dVisibleDistance );
}

bool ServerSettings::setExtraStamina( double d )
{
  dExtraStamina = d;
  return ( true );
}

double ServerSettings::getExtraStamina( ) const
{
  return ( dExtraStamina );
}

bool ServerSettings::setMaximalKickDist( double d )
{
  dMaximalKickDist = d;
  return ( true );
}

double ServerSettings::getMaximalKickDist( ) const
{
  return ( dMaximalKickDist );
}

/*****************************************************************************/
/*******************   CLASS HETEROPLAYERSETTINGS ****************************/
/*****************************************************************************/

void HeteroPlayerSettings::show( ostream &os )
{
  os.setf( ios::left );
  os << dPlayerSpeedMax << " ";
  os.width( 5 );
  os.precision( 4 );
  os.setf( ios::left );
  os << dStaminaIncMax << " " ;
  os.width( 6 );
  os.precision( 4 );
  os.setf( ios::left );
  os << dPlayerDecay  << " ";
  os.width( 5 );
  os.precision( 4 );
  os.setf( ios::left );
  os << dInertiaMoment  << " " ;
  os.width( 8 );
  os.precision( 4 );
  os.setf( ios::left );
  os << dDashPowerRate << " " ;
  os.width( 3 );
  os.precision( 4 );
  os.setf( ios::left );
  os << dPlayerSize     << " " ;
  os.width( 6 );
  os.precision( 4 );
  os.setf( ios::left );
  os << dKickableMargin << " " ;
  os.width( 6 );
  os.precision( 4 );
  os.setf( ios::left );
  os << dKickRand      << " " ;
  os.width( 5 );
  os.precision( 3 );
  os.setf( ios::left );
  os << dExtraStamina    << " " ;
  os.width( 6 );
  os.precision( 4 );
  os.setf( ios::left );
  os << dEffortMin     << " " ;
  os.width( 6 );
  os.setf( ios::left );
  os.precision( 4 );
  os << dEffortMax      << endl ;
/*
  os <<        dPlayerSpeedMax << " " << dStaminaIncMax << " " << dPlayerDecay
     << " " << dInertiaMoment  << " " << dDashPowerRate << " " << dPlayerSize
     << " " << dKickableMargin << " " << dKickRand      << " " << dExtraStamina
     << " " << dEffortMax      << " " << dEffortMin     << endl;
*/
}


/********************* TESTING PURPOSES **************************************/
/*

int main( void )
{
  ServerSettings settings;
//  settings.show( cout );
  settings.readValues( "server.conf", ":" );
//  printf( "------------\n" );
  settings.show( cout );
  cout << "player_size: " << settings.getPlayerSize( ) << endl;
}

*/

---