player.cpp

来自「2009 ROBOCUP 仿真2DSERVER 源码」· C++ 代码 · 共 2,189 行 · 第 1/5 页

//                     PVector kick_noise( drand( -maxrnd, maxrnd ),
//                                         drand( -maxrnd, maxrnd ) );
//                     accel += kick_noise;
//                 }

                // akiyama 2008-01-30
                // new kick noise

                // [0.5, 1]
                double pos_rate = 0.5 + 0.5*( 1.0 - prob );
                // [0.5, 1]
                double speed_rate
                    = 0.5
                    + 0.5 * ( M_stadium.ball().vel().r()
                              / ( ServerParam::instance().ballSpeedMax()
                                  * ServerParam::instance().ballDecay() ) );
                // [0, 2*kick_rand]
                double max_rand = M_kick_rand
                    * power_rate
                    * ( pos_rate + speed_rate );
                PVector kick_noise = PVector::fromPolar( drand( 0.0, max_rand ),
                                                         drand( -M_PI, M_PI ) );
                accel += kick_noise;

                M_stadium.kickTaken( *this, accel );
            }
            else
            {
                M_state |= ( TACKLE | TACKLE_FAULT );
            }
        }
        else
        {
            M_state |= TACKLE_FAULT;
        }
    }
}

void
Player::clang( int min, int max )
{
    //    std::ostrstream resp;
    //    resp << "(ok clang (ver " << min << " " << max << "))" << std::ends;
    //    send( resp.str() );
    //    resp.freeze( false );

    M_clang_min_ver = min;
    M_clang_max_ver = max;

    sendOKClang();

    if( M_team != NULL
        && team()->olcoach() != NULL
        && team()->olcoach()->assigned() )
    {
        M_team->olcoach()->sendPlayerClangVer( *this );
    }
}

void
Player::ear( bool on,
             rcss::pcom::TEAM team_side,
             std::string team_name,
             rcss::pcom::EAR_MODE mode )
{
    Side s = NEUTRAL;
    if ( team_side == rcss::pcom::OUR )
    {
        s = side();
    }
    else if ( team_side == rcss::pcom::OPP )
    {
        s = static_cast< Side >( - side() );
    }
    else if ( team_side == rcss::pcom::LEFT_SIDE )
    {
        s = LEFT;
    }
    else if ( team_side == rcss::pcom::RIGHT_SIDE )
    {
        s = RIGHT;
    }
    else if ( team_name.length() > 0 )
    {
        if ( team_name == M_stadium.teamLeft().name() )
        {
            s = M_stadium.teamLeft().side();
        }
        else if ( team_name == M_stadium.teamRight().name() )
        {
            s = M_stadium.teamRight().side();
        }
        else
        {
            sendErrorNoTeamName( team_name );
            //        std::ostrstream ostr;
            //        ostr << "(error no team with name " << team_name << ")" << std::ends;
            //        send( ostr.str() );
            //        ostr.freeze( false );
            return;
        }
    }

    //std::cerr << "Ear:\n";
    //std::cerr << "\tSide: " << ( side == LEFT ? "left" : "right" ) << std::endl;

    bool partial = true;
    bool complete = true;
    if ( mode == rcss::pcom::PARTIAL )
    {
        complete = false;
    }
    else if ( mode == rcss::pcom::COMPLETE )
    {
        partial = false;
    }

    //std::cerr << "\tOn: " << on << std::endl;
    //std::cerr << "\t\tPartial: " << partial << std::endl;
    //std::cerr << "\t\tComplete: " << complete << std::endl;

    setEar( on, s, complete, partial );
}

// 2008-02-09 akiyama
// comand to change the see message timer
void
Player::synch_see()
{
    //std::cerr << unum() << "  recv synch_see" << std::endl;

    switch ( M_view_width ) {
    case rcss::pcom::NARROW:
        M_vis_angle = defangle * ( 2.0 / 3.0 ); // == sim_step / send_step
        M_vis_send = 1;
        break;
    case rcss::pcom::NORMAL:
        M_vis_angle = defangle * ( 4.0 / 3.0 ); // == 2 * sim_step / send_step
        M_vis_send = 2;
        break;
    case rcss::pcom::WIDE:
        M_vis_angle = defangle * ( 6.0 / 3.0 ); // == 3 * sim_step / send_step
        M_vis_send = 3;
        break;
    default:
        return;
        break;
    }

    M_synch_see = true;
    M_highquality = true;

    // TODO: move to the Observer
    send( "(ok synch_see)" );
}

void
Player::sendInit()
{
    M_init_observer->sendInit();
    M_init_observer->sendServerParams();
    M_init_observer->sendPlayerParams();
    M_init_observer->sendPlayerTypes();
    M_init_observer->sendChangedPlayers();
}

void
Player::sendReconnect()
{
    M_init_observer->sendReconnect();
    M_init_observer->sendServerParams();
    M_init_observer->sendPlayerParams();
    M_init_observer->sendPlayerTypes();
    M_init_observer->sendChangedPlayers();
}

void
Player::sendVisual()
{
    if ( ! M_synch_see )
    {
        M_observer->sendVisual();
    }
}

void
Player::sendSynchVisual()
{
    if ( M_synch_see )
    {
        M_observer->sendVisual();
    }
}

/* contributed by Artur Merke */
void
Player::sendFullstate()
{
    M_fullstate_observer->sendFullState();
}

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;
    }
    M_body_observer->setBodySender( body_cre( body_params ) );

    rcss::VisualSenderPlayer::Params visual_params( getTransport(),
                                                    *this,
                                                    *ser,
                                                    M_stadium );
    rcss::VisualSenderPlayer::Creator vis_cre;
    if ( ! rcss::VisualSenderPlayer::factory().getCreator( vis_cre,
                                                           (int)version() ) )
    {
        return false;
    }
    M_observer->setVisualSender( vis_cre( visual_params ) );


    rcss::InitSenderPlayer::Params init_params( getTransport(),
                                                *this,
                                                *ser,
                                                M_stadium );
    rcss::InitSenderPlayer::Creator init_cre;
    if ( ! rcss::InitSenderPlayer::factory().getCreator( init_cre,
                                                         (int)version() ) )
    {
        return false;
    }
    M_init_observer->setInitSender( init_cre( init_params ) );


    rcss::FullStateSenderPlayer::Params fs_params( getTransport(),
                                                   *this,
                                                   *ser,
                                                   M_stadium );
    rcss::FullStateSenderPlayer::Creator full_cre;
    if ( ! rcss::FullStateSenderPlayer::factory().getCreator( full_cre,
                                                              (int)version() ) )
    {
        return false;
    }
    M_fullstate_observer->setFullStateSender( full_cre( fs_params ) );


    rcss::AudioSenderPlayer::Params audio_params( getTransport(),
                                                  *this,
                                                  *ser,
                                                  M_stadium );
    rcss::AudioSenderPlayer::Creator audio_cre;
    if ( ! rcss::AudioSenderPlayer::factory().getCreator( audio_cre,
                                                          (int)version() ) )
    {
        return false;
    }
    setAudioSender( audio_cre( audio_params ) );

    return true;
}

void
Player::turnImpl()
{
    M_angle_body_committed = this->M_angle_body;
    M_angle_neck_committed = this->M_angle_neck;
    M_vel.assign( 0.0, 0.0 );
    M_accel.assign( 0.0, 0.0 );
}

void
Player::updateAngle()
{
    M_angle_body_committed = this->M_angle_body;
    M_angle_neck_committed = this->M_angle_neck;
}

void
Player::collidedWithPost()
{
    addState( POST_COLLIDE );
    M_post_collide = true;
}

double
Player::maxAccel() const
{
    if ( pos().y < 0.0 )
    {
        return M_max_accel * ( M_team->side() == LEFT
                               ? ServerParam::instance().slownessOnTopForLeft()
                               : ServerParam::instance().slownessOnTopForRight() );
    }
    return M_max_accel;
}

double
Player::maxSpeed() const
{
    if ( pos().y < 0.0 )
    {
        return M_max_speed * ( M_team->side() == LEFT
                               ? ServerParam::instance().slownessOnTopForLeft()
                               : ServerParam::instance().slownessOnTopForRight() );
    }
    return M_max_speed;
}


void
Player::decrementHearCapacity( const Player & sender )
{
    if ( team() == sender.team() )
    {
        M_hear_capacity_from_teammate
            -= ServerParam::instance().hearDecay();
    }
    else
    {
        M_hear_capacity_from_opponent
            -= ServerParam::instance().hearDecay();
    }
}

bool
Player::canHearFullFrom( const Player & sender ) const
{
    if ( team() == sender.team() )
    {
        return M_hear_capacity_from_teammate
            >= (int)ServerParam::instance().hearDecay();
    }
    else
    {
        return M_hear_capacity_from_opponent
            >= (int)ServerParam::instance().hearDecay();
    }
}


void
Player::recoverAll()
{
    M_stamina = ServerParam::instance().staminaMax();
    M_recovery = 1.0;
    M_effort = M_player_type->effortMax();

    recoverStaminaCapacity();

    M_consumed_stamina = 0.0;

    M_hear_capacity_from_teammate = ServerParam::instance().hearMax();
    M_hear_capacity_from_opponent = ServerParam::instance().hearMax();
}

void
Player::recoverStaminaCapacity()
{
    M_stamina_capacity = ServerParam::instance().staminaCapacity();
}

void
Player::updateStamina()
{
    const ServerParam & param = ServerParam::instance();

    if ( M_stamina <= param.recoverDecThr() * param.staminaMax() )
    {
        if ( M_recovery > param.recoverMin() )
        {
            M_recovery -= param.recoverDec();
        }

        if ( M_recovery < param.recoverMin() )
        {
            M_recovery = param.recoverMin();
        }
    }

    if ( M_stamina <= param.effortDecThr() * param.staminaMax() )
    {
        if ( M_effort > M_player_type->effortMin() )
        {
            M_effort -= param.effortDec();
        }

        if ( M_effort < M_player_type->effortMin() )
        {
            M_effort = M_player_type->effortMin();
        }
    }

    if ( M_stamina >= param.effortIncThr() * param.staminaMax() )
    {
        if ( M_effort < M_player_type->effortMax() )
        {
            M_effort += param.effortInc();
            if ( M_effort > M_player_type->effortMax() )
            {
                M_effort = M_player_type->effortMax();
            }
        }
    }

    //M_stamina += ( M_recovery * M_player_type->staminaIncMax() );
    //if ( M_stamina > param.staminaMax() )
    //{
    //    M_stamina = param.staminaMax();
    //}

    double stamina_inc = std::min( M_recovery * M_player_type->staminaIncMax(),
                                   param.staminaMax() - M_stamina );

    if ( param.staminaCapacity() >= 0.0 )
    {
        i