smonitor_dev.h

robocup rcssmonitor-11.1.1.zip

  static const int BUTTON_QUIT;
  static const int BUTTON_NUMBER;

  static const int POPUP_BUTTON_DROP_BALL;
  static const int POPUP_BUTTON_FREE_KICK_LEFT;
  static const int POPUP_BUTTON_FREE_KICK_RIGHT;
  static const int POPUP_BUTTON_NUMBER;

  /****************************************************************************/
  /* begin of SMonitorDevice internal types declaration                       */
  /****************************************************************************/

  struct Options {
    Options();
    int server_port;
    char server_host[STRING_MAX_SIZE];
    int coach_port;
    int protocol_version;
    bool connect_on_start;

    bool keepaway;
    double keepaway_length;
    double keepaway_width;

    bool list_player_types;
    bool show_ball_collisions;
    bool just_edit;
    bool track_ball;
    double player_radius;
    int player_skin;
    Point2d player_num_pos;
    bool show_ball_vel;

    double ball_radius;
    int ball_skin;

    double kick_radius;

    void toggle_track_ball() { track_ball= !track_ball; }
    void toggle_show_ball_vel() { show_ball_vel= !show_ball_vel; }

    RGBcolor c_team_l, c_goalie_l, c_font_l, c_invalid_l;
    RGBcolor c_team_r, c_goalie_r, c_font_r, c_invalid_r;
    RGBcolor c_ball, c_field, c_marigin, c_line, c_goal;
    RGBcolor c_varea_exact, c_varea_fuzzy;

    int info_level;
    static const int info_level_min;
    static const int info_level_def;
    static const int info_level_max;

    int scale_level;
    static const int scale_level_min;
    static const int scale_level_def;
    static const int scale_level_max;
    static const double scale_level_inc;
    static const double scale_level_beg;
    double scale_factor() const;
    bool set_scale_level_from_double(double s);

    static const int MODE_STANDARD;
    static const int MODE_MOVE;
    static const int MODE_SHOW_VIEW_AREA;

    int mode;
    int active_in_mode;

    const char * get_mode_string() const;
    const char * get_mode_value_string() const;
    bool set_mode_from_string(const char * s);

    bool lt_show_spare_space_to_offside_line;
    bool rt_show_spare_space_to_offside_line;
  };

  struct ServerState {
    //long last_packet_ms_time;
    struct Charfield {
      char	name[512] ;
      int len;
      Charfield() { name[0]= '\0'; len = 0;}
      void set( const char* str ) { strncpy(name,str,16); len= strlen(name); }
      void reset() { name[0]= '\0'; }
    };
    ServerState();
    Charfield left_teamname;
    Charfield right_teamname;
    Charfield match_information;
    bool reconnected;
    void reset();
  };

  struct GuessState {
    GuessState() { reset(); }
    void reset() {
      use_stamina= false;
      use_type= false;
    }
    bool use_stamina;
    bool use_type;
  };

  struct Positions {
    struct Ball {
      Point2d pos;
      Point2d vel;
    };
    struct Player {
      Player() { alive= false; type= 0; view_quality= VisualPlayersViewArea::FEEL_RANGE, view_width= 0.0; };
      bool alive;
      int type;
      Point2d pos;
      Angle body_angle;
      Angle head_angle_rel;
      double view_width;
      int view_quality;
      double stamina;
    };

    Positions() {};
    Ball ball;
    Player player[MAX_PLAYER*2];

    Player & ref_player(int i) { return player[i]; };
    void set_player_alive(int i,bool flag=true) { player[i].alive= flag; }
    bool player_alive(int i) { return player[i].alive; }
    void set_player(int i,const Point2d & p,const Angle & a);
    void set_player_pos(int i,const Point2d & p) { player[i].pos= p; }
    void set_ball_pos(const Point2d & p) { ball.pos= p; }
    void set_ball(const Point2d & p, const Point2d & v) { ball.pos= p; ball.vel= v; }
    void print_inline(std::ostream & o);
    void print_formation(std::ostream & o, bool left_half, bool left_team);

    //some info messages (useful for example to recognize offside lines (considers players p1 <= p < p2)
    bool max_x_pos(int p1, int p2, double & x1) const;
    bool max_x_pos(int p1, int p2, double & x1, double & x2) const;
    bool min_x_pos(int p1, int p2, double & x1) const;
    bool min_x_pos(int p1, int p2, double & x1, double & x2) const;
    //lt= left_team, rt= right_team
    bool lt_max_x_pos(double & x1) const { return max_x_pos(0,MAX_PLAYER,x1); }
    bool lt_min_x_pos(double & x1) const { return min_x_pos(0,MAX_PLAYER,x1); }
    bool lt_max_x_pos(double & x1, double & x2) const { return max_x_pos(0,MAX_PLAYER,x1,x2); }
    bool lt_min_x_pos(double & x1, double & x2) const { return min_x_pos(0,MAX_PLAYER,x1,x2); }
    bool rt_max_x_pos(double & x1) const { return max_x_pos(MAX_PLAYER,MAX_PLAYER*2,x1); }
    bool rt_min_x_pos(double & x1) const { return min_x_pos(MAX_PLAYER,MAX_PLAYER*2,x1); }
    bool rt_max_x_pos(double & x1, double & x2) const { return max_x_pos(MAX_PLAYER,MAX_PLAYER*2,x1,x2); }
    bool rt_min_x_pos(double & x1, double & x2) const { return min_x_pos(MAX_PLAYER,MAX_PLAYER*2,x1,x2); }
  };

  struct CoachState {
    CoachState() { left_team= true; }
    bool left_team;
    void toggle_team() { left_team= !left_team; }
  };

    struct PenaltyState {
        int time_;
        int left_score_;
        int left_trial_;
        int right_score_;
        int right_trial_;
        PenaltyState()
            : time_( 0 )
            , left_score_( 0 )
            , left_trial_( 0 )
            , right_score_( 0 )
            , right_trial_( 0 )
          { }
    };
  /****************************************************************************/
  /* end of SMonitorDevice internal types declaration                         */
  /****************************************************************************/

  Options options;
  ServerState server_state;
  GuessState guess;
  Positions server_pos;
  CoachState coach_state;

  VisualBall vis_ball;
  VisualPlayer vis_player[MAX_PLAYER*2];
  VisualPlayersViewArea vis_view_area;
  VisualField vis_field;
  Area2d initial_area;

    std::vector< PenaltyState > M_penalty_state;

  void vis_ball_set_info_level(int lev);
  void vis_player_set_info_level(int lev, VisualPlayer & vis_p, const Positions::Player & p);
  void vis_player_set_info_level(int lev);

  int server_msg_type(void * ptr);
  bool server_interpret_showinfo_t(BuilderBase * build, void *ptr);
  bool server_interpret_msginfo_t(BuilderBase * build, void *ptr);
  bool server_interpret_drawinfo_t(BuilderBase * build, void *ptr);

  bool server_interpret_showinfo_t2(BuilderBase * build, void *ptr); //ver. 2
  bool server_interpret_player_type_t(BuilderBase * build, void *ptr); //ver. 2
  bool server_interpret_server_params_t(BuilderBase * build, void *ptr); //ver. 2

    void updatePenaltyState( const int current_time,
                             const char pmode );

  void show_parser_error_point(std::ostream & out, const char * origin, const char * parse_error_point);
  bool ins_simple_obj(const char * buf, int fref, BuilderBase * build, const char* & next);
  bool server_interpret_frameview_msg(BuilderBase * build, const char * msg, bool enforce_frame= false, int frame= -1); //art!

  bool server_interpret_command_msg(BuilderBase * build, const char * msg);

  /// the object ID of the ball
  static const int id_ball;
  static const int id_invalid;

  /// true if object ID means the ball or a valid player
  bool o_valid(int i) { return ( o_ball(i) || p_valid(i))?true:false; }
  /// true if object ID means the ball
  bool o_ball(int i) { return (i == id_ball)?true:false; }
  /// true if object ID means a player ball
  bool o_player(int i) { return p_valid(i); }
  /// true if the player ID is valid
  bool p_valid(int i) { return (i>= 0 && i < MAX_PLAYER*2)?true:false; }
  /// maps player ID to frame number of this player
  int p_frame(int i) { return i+1; }

  /// maps player ID to number of this player in his team
  int p_number(int i) { return i<MAX_PLAYER?i+1:i+1-MAX_PLAYER; }
  /// maps player ID to team ID
  int p_team(int i) { return i<MAX_PLAYER?0:1; }
  /// return true if player ID belongs to the left team
  bool p_left(int i) { return i<MAX_PLAYER?true:false; }
  /// return true if player ID belongs to the left team
  bool p_right(int i) { return i<MAX_PLAYER?false:true; }
  /// maps player ID to character in '1' ... '9' , 'A', 'B'
  char p_char(int i);

  ///sets player position,
  void set_object_pos(BuilderBase * build, int p_num, const Point2d & pos);

  void set_all_objects_scale(BuilderBase * build, double scale);

  void send_object_pos(int p_num, const Point2d & pos);
  void send_dispinit();
  void send_dispstart();
  void send_dispball(const Point2d & pos);
  void send_dispfoul_left(const Point2d & pos);
  void send_dispfoul_right(const Point2d & pos);
  void send_dispbye();

  bool process_options(const ValueParser & vp);

  template <class T>
  void print_option_entry(std::ostream & o,int mode, const char * option, const T & val, const char * description) const;
  void generic_description_of_options(std::ostream & o, int mode) const;
 public:
  /****************************************************************************/
  /* public interface of SMonitorDevice as defined in InputDevice             */
  /****************************************************************************/
  SMonitorDevice();
  virtual ~SMonitorDevice() { }

  bool set_initial_area(const Area2d & area) { initial_area= area; return true; }
  bool process_options(const char * fname);
  bool process_options(int argc, char const* const* argv);
  void help_options(std::ostream & o) const;
  void help_char_command(std::ostream & o) const;
  void generate_file_options(std::ostream & o) const;

  bool process_char_command(BuilderBase * build, MenuBase * menu, const InputEvent & event);
  bool process_mouse_button_event(BuilderBase * build, const InputEvent & event);
  bool process_menu_button(BuilderBase * build, MenuBase * menu, const InputEvent & event);
  bool process_popup_button(BuilderBase * build, MenuBase * popup, const InputEvent & event);

  bool init_menu(MenuBase * menu);
  bool init_popup(MenuBase * popup);
  bool init_frames(BuilderBase * build);
  bool init_connection();

  bool uses_mouse() const;
  bool uses_popup() const;

  bool destruct();

  bool process_input(fd_set * , BuilderBase * build);

  const char * status_line() { return server_state.match_information.name; }
  int set_fds(fd_set * set);
  bool got_fds(fd_set * set);

    virtual bool is_timeover() const { return timeover; }
};

template <class T>
void SMonitorDevice::print_option_entry(std::ostream & o,int mode, const char * option, const T & val, const char * description) const {
  if (mode == 0)
    o << "\n"
      << "\n# " << description << " (default " << val << ")"
      << "\n" << option << " = "; //<< val;
  else
    o << "\n"
      << "\n" << description
      << "\n-m_" << option << " [" << val << "]";
}



#endif