player_config.h

Go to the documentation of this file.

// -*-c++-*-
 
/*
 *Copyright:
 
 Copyright (C) Hidehisa AKIYAMA
 
 This code is free software; you can redistribute it and/or
 modify it under the terms of the GNU Lesser General Public
 License as published by the Free Software Foundation; either
 version 3 of the License, or (at your option) any later version.
 
 This library is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 Lesser General Public License for more details.
 
 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
 *EndCopyright:
 */
 
 
#ifndef RCSC_PLAYER_PLAYER_CONFIG_H
#define RCSC_PLAYER_PLAYER_CONFIG_H
 
#include <string>
#include <iosfwd>
 
namespace rcsc {
 
class ParamMap;
class ParamParser;
 
class PlayerConfig {
private:
 
    ParamMap * M_param_map;
 
    // basic setting
 
    std::string M_team_name; 
    double      M_version; 
    int         M_reconnect_number; 
    bool        M_goalie; 
 
    int M_interval_msec; 
    int M_server_wait_seconds; 
 
    int M_wait_time_thr_synch_view;
    int M_wait_time_thr_nosynch_view;
 
    int M_normal_view_time_thr;
 
    std::string M_rcssserver_host; 
    int         M_rcssserver_port; 
 
    int M_compression; 
 
    int M_clang_min; 
    int M_clang_max; 
 
    bool M_use_communication; 
    bool M_hear_opponent_audio; 
    int M_audio_shift; 
 
    bool M_use_fullstate; 
    bool M_debug_fullstate; 
 
    bool M_synch_see; 
 
    // confidence value
 
    int M_self_pos_count_thr; 
    int M_self_vel_count_thr; 
    int M_self_face_count_thr; 
 
    int M_ball_pos_count_thr; 
    int M_ball_rpos_count_thr; 
    int M_ball_vel_count_thr; 
 
    int M_player_pos_count_thr; 
    int M_player_vel_count_thr; 
    int M_player_face_count_thr; 
 
 
    int M_player_number;
 
    std::string M_config_dir;
 
    //
    // debug
    //
 
    bool M_debug; 
 
    std::string M_log_dir;
 
    //
    // debug client settings
    //
 
    bool M_debug_server_connect; 
    bool M_debug_server_logging; 
 
    std::string M_debug_server_host; 
    int  M_debug_server_port; 
 
    //
    // offline client settings
    //
 
    bool M_offline_logging; 
    std::string M_offline_log_ext; 
 
    int M_offline_client_number;
 
    //
    // debug logging
    //
 
    int M_debug_start_time; 
    int M_debug_end_time; 
 
    std::string M_debug_log_ext; 
 
    bool M_debug_system; 
    bool M_debug_sensor; 
    bool M_debug_world; 
    bool M_debug_action; 
    bool M_debug_intercept; 
    bool M_debug_kick; 
    bool M_debug_hold; 
    bool M_debug_dribble; 
    bool M_debug_pass; 
    bool M_debug_cross; 
    bool M_debug_shoot; 
    bool M_debug_clear; 
    bool M_debug_block; 
    bool M_debug_mark; 
    bool M_debug_positioning; 
    bool M_debug_role; 
    bool M_debug_plan; 
    bool M_debug_team; 
    bool M_debug_communication; 
    bool M_debug_analyzer; 
    bool M_debug_action_chain; 
 
    bool M_debug_training; 
 
public:
 
    PlayerConfig();
 
    ~PlayerConfig();
 
    void parse( ParamParser & parser );
 
    std::ostream & printHelp( std::ostream & os ) const;
 
protected:
    void setDefaultParam();
 
    void createParamMap();
 
public:
 
    // basic settings
 
    const std::string & teamName() const { return M_team_name; }
 
    double version() const { return M_version; }
 
    int reconnectNumber() const { return M_reconnect_number; }
 
    bool goalie() const { return M_goalie; }
 
    int intervalMSec() const { return M_interval_msec; }
 
    int serverWaitSeconds() const { return M_server_wait_seconds; }
 
    int waitTimeThrSynchView() const { return M_wait_time_thr_synch_view; }
 
    int waitTimeThrNoSynchView() const { return M_wait_time_thr_nosynch_view; }
 
    int normalViewTimeThr() const { return M_normal_view_time_thr; }
 
    const std::string & host() const { return M_rcssserver_host; }
 
    int port() const { return M_rcssserver_port; }
 
    int compression() const { return M_compression; }
 
    int clangMin() const { return M_clang_min; }
 
    int clangMax() const { return M_clang_max; }
 
    bool useCommunication() const { return M_use_communication; }
 
    bool hearOpponentAudio() const { return M_hear_opponent_audio; }
 
    /*
      \brief shift value to encrypt audio encoder
      \return shift value
     */
    int audioShift() const { return M_audio_shift; }
 
    bool useFullstate() const { return M_use_fullstate; }
 
    bool debugFullstate() const { return M_debug_fullstate; }
 
    bool synchSee() const { return M_synch_see; }
 
    // confidence value
 
    int selfPosCountThr() const { return M_self_pos_count_thr; }
 
    int selfVelCountThr() const { return M_self_vel_count_thr; }
 
    int selfFaceCountThr() const { return M_self_face_count_thr; }
 
    int ballPosCountThr() const { return M_ball_pos_count_thr; }
 
    int ballRPosCountThr() const { return M_ball_rpos_count_thr; }
 
    int ballVelCountThr() const { return M_ball_vel_count_thr; }
 
    int playerPosCountThr() const { return M_player_pos_count_thr; }
 
    int playerVelCountThr() const { return M_player_vel_count_thr; }
 
    int playerFaceCountThr() const { return M_player_face_count_thr; }
 
    int playerNumber() const { return M_player_number; }
 
    void setPlayerNumber( const int num ) { M_player_number = num; }
 
    const std::string & configDir() const { return M_config_dir; }
 
    //
    // debug
    //
 
    bool debug() const { return M_debug; }
 
    const std::string & logDir() const { return M_log_dir; }
 
    //
    // debug server settings
    //
 
    bool debugServerConnect() const { return M_debug_server_connect; }
 
    bool debugServerLogging() const { return M_debug_server_logging; }
 
    const std::string & debugServerHost() const { return M_debug_server_host; }
 
    int debugServerPort() const { return M_debug_server_port; }
 
    //
    // offline client
    //
 
    bool offlineLogging() const { return M_offline_logging; }
 
    const std::string & offlineLogExt() const { return M_offline_log_ext; }
 
    int offlineClientNumber() const { return M_offline_client_number; }
 
    //
    // debug logging
    //
 
    int debugStartTime() const { return M_debug_start_time; }
 
    int debugEndTime() const { return M_debug_end_time; }
 
    const std::string & debugLogExt() const { return M_debug_log_ext; }
 
    bool debugSystem() const { return M_debug_system; }
 
    bool debugSensor() const { return M_debug_sensor; }
 
    bool debugWorld() const { return M_debug_world; }
 
    bool debugAction() const { return M_debug_action; }
 
    bool debugIntercept() const { return M_debug_intercept; }
 
    bool debugKick() const { return M_debug_kick; }
 
    bool debugHold() const { return M_debug_hold; }
 
    bool debugDribble() const { return M_debug_dribble; }
 
    bool debugPass() const { return M_debug_pass; }
 
    bool debugCross() const { return M_debug_cross; }
 
    bool debugShoot() const { return M_debug_shoot; }
 
    bool debugClear() const { return M_debug_clear; }
 
    bool debugBlock() const { return M_debug_block; }
 
    bool debugMark() const { return M_debug_mark; }
 
    bool debugPositioning() const { return M_debug_positioning; }
 
    bool debugRole() const { return M_debug_role; }
 
    bool debugPlan() const { return M_debug_plan; }
 
    bool debugTeam() const { return M_debug_team; }
 
 
    bool debugCommunication() const { return M_debug_communication; }
 
 
    bool debugAnalyzer() const { return M_debug_analyzer; }
 
    bool debugActionChain() const { return M_debug_action_chain; }
 
    bool debugTraining() const { return M_debug_training; }
};
 
}
 
#endif