smonitor_dev.c

robocup rcssmonitor-11.1.1.zip

bool SMonitorDevice::process_options(const char * fname) {
  ValueParser vp(fname,"SMonitorDevice");
  return process_options(vp);
}

bool SMonitorDevice::process_options(int argc, char const* const* argv) {
  ValueParser vp(argc,argv,"m_");
  return process_options(vp);
}

void SMonitorDevice:: help_char_command(std::ostream & o) const {
  o << "\n"
    << "server commands:\n"
    << "b = drop ball at current mouse pointer position\n"
    << "c = connect to server\n"
    << "l = free kick for left team\n"
    << "r = free kick for right team\n"
    << "s = start a match\n"
    << "\n"
    << "monitor commands:\n"
    << "m = toggle move/view mode\n"
    << "p = print current positions on cout\n"
    << "P = print current formation (for left or right)\n"
    << "v = toggle displaying future ball position and velocity"
//      << "T = toggle tracking of the ball\n"
    << "\n"
    << "coach commands:\n"
    << "t = toggle current team (starts with left team)\n"
    << "i = position player (of the current team) with number i at mouse pointer position\n"
    << "    i can take following values: 1,2,3,4,5,6,7,8,9\n"
    << "                                 A or 0 which means 10\n"
    << "		                 B which means 11\n";
}

void SMonitorDevice::help_options(std::ostream & o) const {
  o << "\nsoccer monitor options:"
    << "\n"
    << "\n(all colors are define by their rrggbb values)";

  generic_description_of_options(o,1);
}

void SMonitorDevice::generate_file_options(std::ostream & o) const {
  o << "\n[SMonitorDevice]"
    << "\n"
    << "\n### all options can be used on the command line if prefixed with '-m_'"
    << "\n### for example '-m_host localhost' will specify the host of the soccer server"
    << "\n"
    << "\n#color options: all colors are define by their rrggbb values"
    << "\n";
  generic_description_of_options(o,0);
}

bool SMonitorDevice::process_char_command(BuilderBase * build, MenuBase * menu, const InputEvent & event) {
  bool redraw= false;
//  static char buf[100];
//  ostrstream dum_str(buf,100);
  switch (event.key) {
  case 'c':
    if ( options.just_edit ) {
      std::cout << "\nthis key is not set in edit mode";
      break;
    }
    server.init_serv_addr(options.server_host,options.server_port);
    send_dispinit();
    server_state.reset();
    break;
  case 'l':
    if ( options.just_edit ) {
      std::cout << "\nthis key is not set in edit mode";
      break;
    }
    send_dispfoul_left(event.pos);
    break;
#if 1
  case 'm':
    options.active_in_mode= id_invalid;
    if ( options.mode == Options::MODE_STANDARD) {
      options.mode= Options::MODE_MOVE;
    }
    else if ( options.mode == Options::MODE_MOVE) {
      build->set_cmd_set_frame_visible(frame_shadow,0);
      options.mode= Options::MODE_SHOW_VIEW_AREA;
    }
    else if ( options.mode== Options::MODE_SHOW_VIEW_AREA) {
      build->set_cmd_set_frame_visible(frame_varea,0);
      options.mode= Options::MODE_STANDARD;
    }
    menu->set_button_label(BUTTON_MODE,options.get_mode_string());
    return true;
    break;
#endif
  case 'p':
    std::cout << "\n";
    server_pos.print_inline(std::cout);
    std::cout << std::flush;
    break;
  case 'P':
    std::cout << "\n";
    server_pos.print_formation(std::cout,coach_state.left_team, coach_state.left_team);
    std::cout << std::flush;
    break;
  case 'T':
    //options.toggle_track_ball();
    break;
  case 'r':
    if ( options.just_edit ) {
      std::cout << "\nthis key is not set in edit mode";
      break;
    }
    send_dispfoul_right(event.pos);
    break;
  case 's':
    if ( options.just_edit ) {
      std::cout << "\nthis key is not set in edit mode";
      break;
    }
    //server.init_serv_addr(options.server_host,options.server_port);
    send_dispstart();
    break;
  case 'v':
    options.toggle_show_ball_vel();
    if ( options.show_ball_vel ) {
      vis_ball.set_show_vel( server_pos.ball.vel );
    }
    else {
      vis_ball.unset_show_vel();
    }
    return true;
    break;
  case '>':
    break; // just a debugging feature
    if (options.lt_show_spare_space_to_offside_line)
      options.lt_show_spare_space_to_offside_line= false;
    else {
      options.lt_show_spare_space_to_offside_line= true;
      options.rt_show_spare_space_to_offside_line= false;
    }
    break;
  case '<':
    break; //just a debugging feature
    if (options.rt_show_spare_space_to_offside_line)
      options.rt_show_spare_space_to_offside_line= false;
    else {
      options.rt_show_spare_space_to_offside_line= true;
      options.lt_show_spare_space_to_offside_line= false;
    }
    break;
  }

  int o_id= id_invalid;
  if ( 'b' == event.key ) o_id= id_ball;
  else if ( 'A' == event.key || '0' == event.key) o_id= 9;
  else if ( 'B' == event.key ) o_id= 10;
  else o_id= int(event.key)-49;
  if ( p_valid(o_id) && !coach_state.left_team) o_id += 11;

  if ( options.mode == Options::MODE_MOVE && o_valid(o_id) || id_ball == o_id) {
    if ( options.just_edit) {
      set_object_pos(build,o_id,event.pos);
      return true;
    }
    else {
#if 1 // if there is no connection to the server, this is needed
      send_object_pos(o_id,event.pos);
      set_object_pos(build,o_id,event.pos);
      return true;
#else
      send_object_pos(o_id,event.pos);
      return false; //don't redraw
#endif
    }
  }

  if ( options.mode == Options::MODE_SHOW_VIEW_AREA && p_valid( o_id ) ) {
    if (options.active_in_mode == o_id) {
      options.active_in_mode= id_invalid;
      build->set_cmd_set_frame_visible(frame_varea,0);
    }
    else {
      options.active_in_mode= o_id;
      Positions::Player & p= server_pos.ref_player(options.active_in_mode);
      build->set_cmd_set_frame_pos_ang(frame_varea,p.pos,p.body_angle+p.head_angle_rel);
      vis_view_area.set_view_mode(p.view_quality, p.view_width);
      build->set_cmd_set_frame_visible(frame_varea,1);
    }
    return true; //redraw
  }

  switch (event.key) {
  case 't': coach_state.toggle_team(); break;
  case 'e':
#if 0
    if ( options.just_edit ) {
      std::cout << "\nthis key is not set in edit mode";
      break;
    }
    coach.send_msg("(ear on)",9);
#else
    std::cout << "\nthis key is not set anymore";
#endif
    break;
    //case 'm': COACH::sock.send_msg("(change_mode play_on)",22);
  }
  return redraw;
}

bool SMonitorDevice::process_mouse_button_event(BuilderBase * build, const InputEvent & event) {
  //options.active_in_mode= id_invalid;
  static unsigned long last_time=0;
  //if (event.mouse_button != 2)
  //  return false;

  if ( event.mouse_button == 2 &&
       event.mouse_button_state == InputEvent::MOUSE_BUTTON_PRESSED ) {
    Point2d rel;
    double min= 100.0;
    int p_min= id_invalid;
    for (int i=0; i<MAX_PLAYER*2; i++) {
      rel.x= event.pos.x - server_pos.player[i].pos.x;
      rel.y= event.pos.y - server_pos.player[i].pos.y;

      //take the greater absolute value
      double dum=  fabs(rel.x) > fabs(rel.y) ? fabs(rel.x) : fabs(rel.y);

      if ( dum < min ) {
	min= dum;
	p_min= i;
      }
    }
    rel.x= event.pos.x - server_pos.ball.pos.x;
    rel.y= event.pos.y - server_pos.ball.pos.y;
    double dum=  fabs(rel.x) > fabs(rel.y) ? fabs(rel.x) : fabs(rel.y);
    if ( dum < min ) {
      min= dum;
      p_min= id_ball;
    }
    if ( min <= options.kick_radius * 1.5 * options.scale_factor() )
      options.active_in_mode= p_min;
    else
      options.active_in_mode= id_invalid;
    //std::cout << "\noptions.active_in_mode= " << options.active_in_mode << flush;
    if ( options.mode == Options::MODE_MOVE ) {
      if ( o_valid(options.active_in_mode) ) {
	build->set_cmd_set_frame_pos(frame_shadow, event.pos);
	build->set_cmd_set_frame_visible(frame_shadow,1);
      }
    }
    else if ( options.mode == Options::MODE_SHOW_VIEW_AREA ) {
      if ( !p_valid( options.active_in_mode))
	build->set_cmd_set_frame_visible(frame_varea,0);
      else {
	Positions::Player & p= server_pos.ref_player(options.active_in_mode);
	build->set_cmd_set_frame_pos_ang(frame_varea,p.pos,p.body_angle+p.head_angle_rel);
	vis_view_area.set_view_mode(p.view_quality, p.view_width);
	build->set_cmd_set_frame_visible(frame_varea,1);
      }
      return true; //redraw
    }
    //std::cout << "\n>>>>>>>>>>>>>>>>>>>> min= " << min << " " << options.kick_radius * 1.5;
    return false; //no need for redraw
  }

  if ( event.mouse_button_state == InputEvent::MOUSE_BUTTON_MOTION
       && options.mode == Options::MODE_MOVE)
      if ( p_valid( options.active_in_mode)
           && event.time > 75 + last_time )
      {
          build->set_cmd_set_frame_pos( p_frame(options.active_in_mode),
                                        event.pos );
          last_time = event.time;
          return true;
      }
      else if ( o_ball(options.active_in_mode)
                && event.time > 75 + last_time )
      {
          build->set_cmd_set_frame_pos(frame_ball, event.pos);
          last_time = event.time;
          return true;
      }
      else
          return false;

  if ( event.mouse_button == 2 &&
       event.mouse_button_state == InputEvent::MOUSE_BUTTON_RELEASED && options.mode == Options::MODE_MOVE) {
    if ( !o_valid(options.active_in_mode) )
      return false;

    bool res= false;
    if (options.just_edit) {
      set_object_pos(build,options.active_in_mode, event.pos);
      res= true;
    }
    else {
#if 1
      set_object_pos(build,options.active_in_mode, event.pos); //is needed
      res= true;                       // when no connection to a server is established
#endif
      send_object_pos(options.active_in_mode, event.pos); //send new pos to server!
    }

    build->set_cmd_set_frame_visible(frame_shadow,0);
    last_time= 0;
    options.active_in_mode= id_invalid;
    return res;
  }

  return false;
}

bool SMonitorDevice::process_menu_button(BuilderBase * build, MenuBase * menu, const InputEvent & event) {
  char buf[20];
  bool chg= false;
  //static unsigned long last_time=0;
  switch ( event.menu_button ) {
  case BUTTON_START:
    send_dispstart();
    return false;

  case BUTTON_RECONNECT:
    if ( options.just_edit ) {
      std::cout << "\nthis key is not set in edit mode";
      break;
    }
    server.init_serv_addr(options.server_host,options.server_port);
    send_dispinit();
    server_state.reset();
    return false;

  case BUTTON_SCALE_LEVEL:
    if (event.mouse_button==1) {
      chg= false;
      if (options.scale_level > options.scale_level_min) {
	options.scale_level--;
	chg= true;
      }
    }
    else {
      if (options.scale_level < options.scale_level_max) {
	options.scale_level++;
	chg= true;
      }
    }
    if (chg) {
      double scale= options.scale_factor();
      sprintf(buf,"scale %.1f", scale);
      menu->set_button_label(BUTTON_SCALE_LEVEL,buf);
      set_all_objects_scale(build, scale);
    }
    return chg;

  case BUTTON_INFO_LEVEL:
    if (event.mouse_button==1) {
      chg= false;
      if (options.info_level > options.info_level_min) {
	options.info_level--;
	chg= true;
      }
    }
    else {
      if (options.info_level < options.info_level_max) {
	options.info_level++;
	chg= true;
      }
    }
    if (chg) {
      sprintf(buf,"detail %d", options.info_level);
      vis_player_set_info_level(options.info_level);
      vis_ball_set_info_level(options.info_level);
      menu->set_button_label(BUTTON_INFO_LEVEL,buf);
    }
    return chg;

  case BUTTON_MODE:
    options.active_in_mode= id_invalid;

    chg= false;
    if (event.mouse_button==1) {
      if ( options.mode== Options::MODE_MOVE) {
	build->set_cmd_set_frame_visible(frame_shadow,0);
	options.mode= Options::MODE_STANDARD;
	chg= true;
      }
      else if ( options.mode== Options::MODE_SHOW_VIEW_AREA) {
	build->set_cmd_set_frame_visible(frame_varea,0);
	options.mode= Options::MODE_MOVE;
	chg= true;
      }
    }
    else {
      if ( options.mode== Options::MODE_STANDARD) {
	options.mode= Options::MODE_MOVE;
	chg= true;
      }
      else if ( options.mode== Options::MODE_MOVE) {
	build->set_cmd_set_frame_visible(frame_shadow,0);
	options.mode= Options::MODE_SHOW_VIEW_AREA;
	chg= true;
      }
    }
    if (chg)
      menu->set_button_label(BUTTON_MODE,options.get_mode_string());

    return chg;
  case BUTTON_UNZOOM:
    build->set_cmd_set_view_area(initial_area);
    return true;
  case BUTTON_QUIT:
    menu->set_exit_program();

    return false;

  }
  return false;
}

bool SMonitorDevice::process_popup_button(BuilderBase * build, MenuBase * popup, const InputEvent & event) {
  static Point2d pos;

  //std::cout << "\npos= " << pos.x << "," << pos.y << flush;
  //std::cout << "\ninput_pos= " << event.pos.x << "," << event.pos.y << flush;

  if ( event.mouse_button_state == InputEvent::MOUSE_BUTTON_PRESSED) {
    pos= event.pos;
    return false; //don't redraw
  }

  switch (event.menu_button) {
  case POPUP_BUTTON_DROP_BALL:
    send_dispball( pos );
    //set_objec