player.cc

在LINUX下运行的仿真机器人服务器源代码

  else
  {
    if ( highquality )
    {
      VisualSensor_v1::high_data_t data;
      data.set ( *stadium, *this );
      send ( data );
    }
    else
    {
      VisualSensor_v1::low_data_t data;
      data.set ( *stadium, *this );
      send ( data );
    }
  }
}

/* contributed by Artur Merke */
void Player::send_fullstate_information() {
    sendFullState();
    return;

    const char *quality = NULL ;
    const char *width = NULL ;
    const char high[] = "high";
    const char low[] = "low";
    const char narrow[] = "narrow";
    const char wide[] = "wide";
    const char normal[] = "normal";

    const float quantize_step = .001;
  
    quality = (highquality ? high : low ) ;

    if (vis_angle == defangle/2)
        width = narrow ;
    else if (vis_angle == defangle*2)
        width = wide;
    else
        width = normal;

#ifdef HAVE_SSTREAM
    std::ostringstream ostr;
#else
    std::ostrstream ostr;
#endif
    ostr.precision(6);
    ostr << "(fullstate " << stadium->time;

    if( stadium->mode == PM_FreeKick_Left 
        && stadium->M_caught_ball )
        ostr  << " (pmode goalie_catch_ball_l)" ;
    else if( stadium->mode == PM_FreeKick_Right 
             && stadium->M_caught_ball )
        ostr  << " (pmode goalie_catch_ball_r)";
    else
        ostr  << " (pmode " << PlayModeString[stadium->mode] << ")" ;
    
    
  
    if ( version >= 8.0 )
    {
        rcss::geom::Vector2D arm_vec;
        M_arm.getRelDest ( rcss::geom::Vector2D ( pos.x, pos.y ),
                           angle_body + angle_neck_committed,
                           arm_vec );
        ostr << " (vmode " << quality << " " << width
//             << ") (stamina " << stamina //stamina
//             << " " << effort
//             << " " << recovery
             << ") (count " << count_kick 
             << " " << count_dash
             << " " << count_turn
             << " " << count_catch
             << " " << count_move
             << " " << count_turn_neck
             << " " << count_change_view
             << " " << count_say
             << ") (arm (movable " << M_arm.getCyclesTillMovable ()
             << ") (expires " << M_arm.getCyclesTillExpiry ()
             << ") (target "<< arm_vec.getMag () << " " << Rad2Deg ( arm_vec.getHead () )
             << ") (count " << M_arm.getCounter () 
             << ")) (score " << team->point;
        if ( team == stadium->team_l )
        {
            if ( stadium->team_r == NULL )
                ostr << " " << 0;
            else
                ostr << " " << stadium->team_r->point;
        }
        else
        {
            if ( stadium->team_l == NULL )
                ostr << " " << 0;
            else
                ostr << " " << stadium->team_l->point;	    
        }
        ostr << ")";
    }
    else
    {
        ostr << " (vmode " 
             << quality << " " << width
             << ") (score " << stadium->team_l->point 
             << " " << stadium->team_r->point 
             << ")";
    }
    //print ball information
    if ( version >= 8.0 )
    {
        ostr << " ((b)"
             << " " << stadium->ball->pos.x
             << " " << stadium->ball->pos.y
             << " " << stadium->ball->vel.x
             << " " << stadium->ball->vel.y
             << ")";
    }
    else
    {
        ostr << " (ball"
             << " " << Quantize(stadium->ball->pos.x, quantize_step)
             << " " << Quantize(stadium->ball->pos.y, quantize_step)
             << " " << Quantize(stadium->ball->vel.x, quantize_step)
             << " " << Quantize(stadium->ball->vel.y, quantize_step)
             << ")";
    }
    //print players information
    for (int k=0; k< 2*MAX_PLAYER; k++) {
        Player* p = stadium->player[k];
        char side = (p->team->side == LEFT) ? 'l' : 'r';

        if (p->alive == DISABLE)
            continue;

        if ( version >= 8.0 )
        {
        
            ostr << " ((p " << side 
                 << " " << p->unum;
            if ( p->goalie )
                ostr << " g";
            else
                ostr << " " << p->player_type_id; // hetro player type
            ostr << ") " << p->pos.x //pos_x
                 << " " << p->pos.y //pos_y
                 << " " << p->vel.x //vel_x
                 << " " << p->vel.y //vel_y
                 << " " << Rad2Deg(p->angle_body)
                 << " " << Rad2Deg(p->angle_neck_committed); //neck_angle
            if ( p->M_arm.isPointing () )
            {
                rcss::geom::Vector2D arm_vec;
                p->M_arm.getRelDest ( rcss::geom::Vector2D ( p->pos.x, p->pos.y ),
                                      p->angle_body + p->angle_neck_committed,
                                      arm_vec );
                ostr << " " << arm_vec.getMag () 
                     << " " << Rad2Deg ( arm_vec.getHead () );
            }
            ostr << " (stamina " << p->stamina //stamina
                 << " " << p->effort
                 << " " << p->recovery
                 << "))";
        }
        else
        {
            ostr << " (" << side << "_" << p->unum 
                 << " " << Quantize(p->pos.x, quantize_step) //pos_x
                 << " " << Quantize(p->pos.y, quantize_step) //pos_y
                 << " " << Quantize(p->vel.x, quantize_step) //vel_x
                 << " " << Quantize(p->vel.y, quantize_step) //vel_y
                 << " " << Quantize(Rad2Deg(p->angle_body), quantize_step)
                 << " " << Quantize(Rad2Deg(p->angle_neck_committed), quantize_step) //neck_angle
                 << " " << int(p->stamina) //stamina
                 << " " << Quantize(p->effort, .0001)
                 << " " << Quantize(p->recovery, .0001)
                 << ")";
        }
    }

    ostr << ")";

#ifdef HAVE_SSTREAM
    send( ostr.str().c_str() );
#else
    ostr << std::ends;
    send( ostr.str() );
    ostr.freeze( false );
#endif

}

void Player::send ( const BodySensor_v1::data_t& data )
{
#ifdef HAVE_SSTREAM
  std::ostringstream o;
#else
  std::ostrstream o;
#endif

  o << "(sense_body " << data.M_time
    << " (view_mode " << data.M_quality << " " << data.M_width
    << ") (stamina " << data.M_stamina << " " << data.M_effort
    << ") (speed " << data.M_vel_mag
    << ") (kick " << data.M_count_kick
    << ") (dash " << data.M_count_dash
    << ") (turn " << data.M_count_turn
    << ") (say " << data.M_count_say
    << "))";
#ifdef HAVE_SSTREAM
  send ( o.str().c_str() );
#else
  o  << std::ends ;
  send ( o.str() );
  o.freeze( false );
#endif

}

void Player::send ( const BodySensor_v5::data_t& data )
{
#ifdef HAVE_SSTREAM
  std::ostringstream o;
#else
  std::ostrstream o;
#endif

  o << "(sense_body " << data.M_time
    << " (view_mode " << data.M_quality << " " << data.M_width
    << ") (stamina " << data.M_stamina << " " << data.M_effort
    << ") (speed " << data.M_vel_mag
    << ") (head_angle " << data.M_head_angle 
    << ") (kick " << data.M_count_kick
    << ") (dash " << data.M_count_dash
    << ") (turn " << data.M_count_turn
    << ") (say " << data.M_count_say
    << ") (turn_neck " << data.M_count_turn_neck
    << "))";
#ifdef HAVE_SSTREAM
  send ( o.str().c_str() );
#else
  o  << std::ends ;
  send ( o.str() );
  o.freeze( false );
#endif
}

void Player::send ( const BodySensor_v6::data_t& data )
{
#ifdef HAVE_SSTREAM
  std::ostringstream o;
#else
  std::ostrstream o;
#endif

  o << "(sense_body " << data.M_time
    << " (view_mode " << data.M_quality << " " << data.M_width
    << ") (stamina " << data.M_stamina << " " << data.M_effort
    << ") (speed " << data.M_vel_mag << " " << data.M_vel_head
    << ") (head_angle " << data.M_head_angle 
    << ") (kick " << data.M_count_kick
    << ") (dash " << data.M_count_dash
    << ") (turn " << data.M_count_turn
    << ") (say " << data.M_count_say
    << ") (turn_neck " << data.M_count_turn_neck
    << "))";
#ifdef HAVE_SSTREAM
  send ( o.str().c_str() );
#else
  o  << std::ends ;
  send ( o.str() );
  o.freeze( false );
#endif
}

void Player::send ( const BodySensor_v7::data_t& data )
{
#ifdef HAVE_SSTREAM
  std::ostringstream o;
#else
  std::ostrstream o;
#endif

  o << "(sense_body " << data.M_time
    << " (view_mode " << data.M_quality << " " << data.M_width
    << ") (stamina " << data.M_stamina << " " << data.M_effort
    << ") (speed " << data.M_vel_mag << " " << data.M_vel_head
    << ") (head_angle " << data.M_head_angle 
    << ") (kick " << data.M_count_kick
    << ") (dash " << data.M_count_dash
    << ") (turn " << data.M_count_turn
    << ") (say " << data.M_count_say
    << ") (turn_neck " << data.M_count_turn_neck
    << ") (catch " << data.M_count_catch
    << ") (move " << data.M_count_move
    << ") (change_view " << data.M_count_change_view
    << "))";
#ifdef HAVE_SSTREAM
  send ( o.str().c_str() );
#else
  o  << std::ends ;
  send ( o.str() );
  o.freeze( false );
#endif
}

void Player::send ( const BodySensor_v8::data_t& data )
{
#ifdef HAVE_SSTREAM
  std::ostringstream o;
#else
  std::ostrstream o;
#endif

  o << "(sense_body " << data.M_time
    << " (view_mode " << data.M_quality << " " << data.M_width
    << ") (stamina " << data.M_stamina << " " << data.M_effort
    << ") (speed " << data.M_vel_mag << " " << data.M_vel_head
    << ") (head_angle " << data.M_head_angle 
    << ") (kick " << data.M_count_kick
    << ") (dash " << data.M_count_dash
    << ") (turn " << data.M_count_turn
    << ") (say " << data.M_count_say
    << ") (turn_neck " << data.M_count_turn_neck
    << ") (catch " << data.M_count_catch
    << ") (move " << data.M_count_move
    << ") (change_view " << data.M_count_change_view
    << ") (arm (movable " << data.M_arm_state.cyclesTillMovable ()
    << ") (expires " << data.M_arm_state.cyclesTillExpires () 
    << ") (target " << data.M_arm_state.dist () 
    << " " << data.M_arm_state.head ()
    << ") (count " << data.M_arm_state.count ()
    << ")) (focus (target ";
  if( data.M_focus_target == NULL )
    o << "none";
  else
    {
      if( data.M_focus_target->team == stadium->team_l )
        o << "l ";
      else
        o << "r ";
      o << data.M_focus_target->unum;
    }
  o << ") (count " << data.M_focus_count 
    << ")) (tackle (expires " << data.M_tackle_cycles_remaining
    << ") (count " << data.M_tackle_count
    << "))"
    << ")";
#ifdef HAVE_SSTREAM
  send ( o.str().c_str() );
#else
  o  << std::ends ;
  send ( o.str() );
  o.freeze( false );
#endif
}


bool Player::setSenders()
{
    rcss::SerializerPlayer::Creator ser_cre;
    if( !rcss::SerializerPlayer::factory().getCreator( ser_cre,
						       (int)version ) )
	return false;
    const rcss::SerializerPlayer* ser = ser_cre();
    if( !ser )
	return false;
    
    rcss::BodySenderPlayer::Params body_params( getTransport(),
                                                *this,
                                                *ser );
    rcss::BodySenderPlayer::Creator body_cre;
    if( !rcss::BodySenderPlayer::factory().getCreator( body_cre,
						       (int)version ) )
	return false;
    setBodySender( body_cre( body_params ) );
    
    rcss::VisualSenderPlayer::Params visual_params( getTransport(),
                                                    *this,
                                                    *stadium,
                                                    *ser );
    rcss::VisualSenderPlayer::Creator vis_cre;
    if( !rcss::VisualSenderPlayer::factory().getCreator( vis_cre,
							 (int)version ) )
	return false;
    setVisualSender( vis_cre( visual_params ) );
    
    
    rcss::InitSenderPlayer::Params init_params( getTransport(),
                                                *this,
                                                *stadium,
                                                *ser );

    rcss::InitSenderPlayer::Creator init_cre;
    if( !rcss::InitSenderPlayer::factory().getCreator( init_cre,
						       (int)version ) )
	return false;
    
    setInitSender( init_cre( init_params ) );    
    
    
    rcss::FullStateSenderPlayer::Params fs_params( getTransport(),
                                                   *this,
                                                   *stadium,
                                                   *ser );
    
    rcss::FullStateSenderPlayer::Creator full_cre;
    if( !rcss::FullStateSenderPlayer::factory().getCreator( full_cre,
							    (int)version ) )
	return false;
    setFullStateSender( full_cre( fs_params ) );
    
    
    rcss::AudioSenderPlayer::Params audio_params( *stadium,
                                                  getTransport(),
                                                  *this,
                                                  *ser );

    rcss::AudioSenderPlayer::Creator audio_cre;
    if( !rcss::AudioSenderPlayer::factory().getCreator( audio_cre,
							(int)version ) )
	return false;
    
    setAudioSender( audio_cre( audio_params ) );
    return true;
}