audio.cpp

2009 ROBOCUP 仿真2DSERVER 源码

        free( i->second );
    }
    M_coach_msgs.clear();

    for ( self_msg_cont_t::iterator i = M_self_msgs.begin();
          i != M_self_msgs.end();
          ++i )
    {
        sendCachedSelfAudio( *i );
        free( *i );
    }
    M_self_msgs.clear();

    while ( ! M_player_msgs.empty() )
    {
        State::key_value_t data = M_state_p->getMsg( M_player_msgs );
        sendCachedNonSelfPlayerAudio( *(data.first), data.second );
        free( data.second );
    }
}

void
AudioSenderPlayerv8::focusOn( const Player & player )
{
    M_focused.focusOn ( &player );
    M_state_p = &M_focused;
    M_focus_count++;
}

void
AudioSenderPlayerv8::focusOff()
{
    M_state_p = &M_unfocused;
    M_focus_count++;
}


void
AudioSenderPlayerv8::sendCachedCoachAudio( const Coach & coach,
                                           const char * msg )
{
    AudioSenderPlayerv7::sendCoachAudio( coach, msg );
}

void
AudioSenderPlayerv8::sendCachedSelfAudio( const char * msg )
{
    AudioSenderPlayerv7::sendSelfAudio( msg );
}

void
AudioSenderPlayerv8::sendCachedNonSelfPlayerAudio( const Player & player,
                                                   const char * msg )
{
    //if ( nonSelfPlayerPredicate( player ) )
    {
        if ( nonSelfPlayerFullPredicate( player ) )
        {
            if ( ( player.side() == LEFT && M_left_complete )
                 || ( player.side() == RIGHT && M_right_complete ) )
            {
                int dir = Rad2IDeg( M_listener.angleFromBody( player ) );
                if ( M_listener.team() == player.team() )
                {
                    M_serializer.serializeAllyAudioFull( transport(),
                                                         M_stadium.time(),
                                                         dir,
                                                         player.unum(),
                                                         msg );
                }
                else
                {
                    M_serializer.serializeOppAudioFull( transport(),
                                                        M_stadium.time(),
                                                        dir,
                                                        msg );
                }
                transport() << std::ends << std::flush;
                postNonSelfPlayer( player );
            }
        }
        else
        {
            if ( ( player.side() == LEFT && M_left_partial )
                 || ( player.side() == RIGHT && M_right_partial ) )
            {
                if ( M_listener.team() == player.team() )
                {
                    M_serializer.serializeAllyAudioShort( transport(),
                                                          M_stadium.time(),
                                                          player.unum() );
                }
                else
                {
                    M_serializer.serializeOppAudioShort( transport(),
                                                         M_stadium.time() );
                }
                transport() << std::ends << std::flush;
            }
        }
    }
}

AudioSenderPlayerv8::Unfocused::key_value_t
AudioSenderPlayerv8::Unfocused::getMsg( msg_cont_t & msgs )
{
    if ( msgs.size() == 1 )
    {
        key_value_t rval = *(msgs.begin());
        msgs.clear();
        return rval;
    }
    else
    {
        //boost::uniform_smallint<> rand_int( 0, msgs.size() - 1 );
        //int idx = rand_int( rcss::random::DefaultRNG::instance() );
        int idx = irand( msgs.size() );
        msg_cont_t::iterator iter = msgs.begin();
        for( int i = 0; i < idx; ++i )
            ++iter;

        key_value_t rval = *iter;
        msgs.erase( iter );
        return rval;
    }
}

AudioSenderPlayerv8::Focused::key_value_t
AudioSenderPlayerv8::Focused::getMsg( msg_cont_t & msgs )
{
#if 1
     std::pair< msg_cont_t::iterator, msg_cont_t::iterator > iters;
     //iters = equal_range ( msgs.begin (), msgs.end (), M_key, msgs.value_comp () );
     //can't get equal_range to work with a mulit_map.  Do it manually instead.
     iters.first = msgs.find( M_key );
     iters.second = msgs.end();

     for ( msg_cont_t::iterator i = iters.first;
           i != iters.second; //msgs.end();
           ++i )
     {
         if ( i->first != M_key )
         {
             iters.second = i;
             break;
         }
     }
#else
    if ( M_key == NULL )
        return Unfocused::getMsg( msgs );

    std::pair< msg_cont_t::iterator, msg_cont_t::iterator > iters
        = msgs.equal_range( M_key );
#endif
    if ( iters.first == iters.second )
        // then there was no message from the player we are focused
        // on, so just get a message at random
        return Unfocused::getMsg( msgs );

    int count = 0;
    for ( msg_cont_t::iterator i = iters.first;
          i != iters.second;
          ++i )
    {
        ++count;
    }

    if ( count == 1 )
    {
        // then there was only one message from the player we are
        // focused on, so just return that.
        key_value_t rval = *(iters.first);
        msgs.erase( iters.first );
        return rval;
    }
    // otherwise return one of those messages at random
    //boost::uniform_smallint<> rand_int( 0, count - 1 );
    //int idx = rand_int( rcss::random::DefaultRNG::instance() );
    int idx = irand( count );
    msg_cont_t::iterator iter = iters.first;
    for( int i = 0; i < idx; i++ )
        iter++;

    msgs.erase( iter );
    return *iter;
}


void
AudioSenderPlayerv8::setEar( bool on,
                             Side side,
                             bool complete,
                             bool partial )
{
    if ( side != RIGHT )
    {
        if ( complete )
        {
            M_left_complete = on;
            //std::cout << "Set left complete to: " << on << std::endl;
        }
        if ( partial )
        {
            M_left_partial = on;
            //std::cout << "Set left partial to: " << on << std::endl;
        }
    }
    if ( side != LEFT )
    {
        if ( complete )
        {
            M_right_complete = on;
            //std::cout << "Set right complete to: " << on << std::endl;
        }
        if ( partial )
        {
            M_right_partial = on;
            //std::cout << "Set right partial to: " << on << std::endl;
        }
    }
}

AudioSenderCoach::FactoryHolder &
AudioSenderCoach::factory()
{
    static FactoryHolder rval;
    return rval;
}

AudioSenderCoach::AudioSenderCoach( const Params & params )
    : AudioSender( params.m_stadium,
                   params.m_transport ),
      M_listener( params.m_listener ),
      M_serializer( params.m_serializer )
{

}

AudioSenderCoach::~AudioSenderCoach()
{
    //std::cerr << "delete AudioSenderCoach" << std::endl;
}


bool
AudioSenderCoach::generalPredicate() const
{
    return ( ( ServerParam::instance().coachMode()
               || ServerParam::instance().coachWithRefereeMode() )
             && M_listener.isEarOn() );
}



void
AudioSenderCoachv1::sendRefereeAudio( const char * msg )
{
    if ( generalPredicate() )
    {
        M_serializer.serializeRefereeAudio( transport(), M_stadium.time(), msg );
        transport() << std::ends << std::flush;
    }
}

void
AudioSenderCoachv1::sendCoachAudio( const Coach & coach,
                                    const char * msg )
{
    if ( generalPredicate() )
    {
        std::string name;
        switch( coach.side() ) {
        case NEUTRAL:
            name = REFEREE_NAME;
            break;

        case LEFT:
            name = OLCOACH_NAME_L;
            break;

        case RIGHT:
            name = OLCOACH_NAME_R;
            break;

        default:
            // don't know what we have hear so don't send anything
            return;
        }
        M_serializer.serializeCoachAudio( transport(),
                                          M_stadium.time(),
                                          name,
                                          msg );
        transport() << std::ends << std::flush;
    }
}

void
AudioSenderCoachv1::sendCoachStdAudio( const rcss::clang::Msg & msg )
{
    if ( generalPredicate() )
    {
        std::string name;
        switch ( msg.getSide() ) {
        case LEFT:
            name = OLCOACH_NAME_L;
            break;

        case RIGHT:
            name = OLCOACH_NAME_R;
            break;

        default:
            // don't know what we have hear so don't send anything
            return;
        }
        M_serializer.serializeCoachStdAudio( transport(),
                                             M_stadium.time(),
                                             name,
                                             msg );
        transport() << std::ends << std::flush;
    }
}

void
AudioSenderCoachv1::sendPlayerAudio( const Player & player,
                                     const char * msg )
{
    if ( generalPredicate() )
    {
        M_serializer.serializePlayerAudio( transport(),
                                           M_stadium.time(),
                                           player.name(),
                                           msg );
        transport() << std::ends << std::flush;
    }
}

void
AudioSenderCoachv7::sendPlayerAudio( const Player & player,
                                     const char * msg )
{
    if ( generalPredicate() )
    {
        M_serializer.serializePlayerAudio( transport(),
                                           M_stadium.time(),
                                           player.shortName(),
                                           msg );
        transport() << std::ends << std::flush;
    }
}


AudioSenderOnlineCoach::FactoryHolder &
AudioSenderOnlineCoach::factory()
{
    static FactoryHolder rval;
    return rval;
}


AudioSenderOnlineCoach::AudioSenderOnlineCoach( const Params & params )
    : AudioSender( params.m_stadium, params.m_transport ),
      M_listener( params.m_listener ),
      M_serializer( params.m_serializer )
{

}

AudioSenderOnlineCoach::~AudioSenderOnlineCoach()
{
    //std::cerr << "delete AudioSenderOnlineCoach" << std::endl;
}


bool
AudioSenderOnlineCoach::generalPredicate() const
{
    return M_listener.assigned();
}


bool
AudioSenderOnlineCoach::coachPredicate( const Coach & coach ) const
{
    return generalPredicate() && coach.side() == NEUTRAL;
}


void
AudioSenderOnlineCoachv1::sendRefereeAudio( const char * msg )
{
    if ( generalPredicate() )
    {
        M_serializer.serializeRefereeAudio( transport(),
                                            M_stadium.time(),
                                            REFEREE_NAME,
                                            msg );
        transport() << std::ends << std::flush;
    }
}

void
AudioSenderOnlineCoachv1::sendCoachAudio( const Coach & coach,
                                          const char * msg )
{
    if ( coachPredicate( coach ) )
    {
        M_serializer.serializeRefereeAudio ( transport(),
                                             M_stadium.time(),
                                             REFEREE_NAME,
                                             msg );
        transport() << std::ends << std::flush;
    }
}

void
AudioSenderOnlineCoachv1::sendPlayerAudio( const Player & player,
                                           const char * msg )
{
    if ( generalPredicate() )
    {
        M_serializer.serializePlayerAudio( transport(),
                                           M_stadium.time(),
                                           player.name(),
                                           msg );
        transport() << std::ends << std::flush;
    }
}

void
AudioSenderOnlineCoachv7::sendPlayerAudio( const Player & player,
                                           const char * msg )
{
    if ( generalPredicate() )
    {
        M_serializer.serializePlayerAudio( transport(),
                                           M_stadium.time(),
                                           player.shortName(),
                                           msg );
        transport() << std::ends << std::flush;
    }
}

namespace audio {

template< typename Sender >
AudioSender::Ptr
create( const AudioSenderPlayer::Params & params )
{
    return AudioSender::Ptr( new Sender( params ) );
}

RegHolder vp1 = AudioSenderPlayer::factory().autoReg( &create< AudioSenderPlayerv1 >, 1 );
RegHolder vp2 = AudioSenderPlayer::factory().autoReg( &create< AudioSenderPlayerv1 >, 2 );
RegHolder vp3 = AudioSenderPlayer::factory().autoReg( &create< AudioSenderPlayerv1 >, 3 );
RegHolder vp4 = AudioSenderPlayer::factory().autoReg( &create< AudioSenderPlayerv1 >, 4 );
RegHolder vp5 = AudioSenderPlayer::factory().autoReg( &create< AudioSenderPlayerv1 >, 5 );
RegHolder vp6 = AudioSenderPlayer::factory().autoReg( &create< AudioSenderPlayerv1 >, 6 );
RegHolder vp7 = AudioSenderPlayer::factory().autoReg( &create< AudioSenderPlayerv7 >, 7 );
RegHolder vp8 = AudioSenderPlayer::factory().autoReg( &create< AudioSenderPlayerv8 >, 8 );
RegHolder vp9 = AudioSenderPlayer::factory().autoReg( &create< AudioSenderPlayerv8 >, 9 );
RegHolder vp10 = AudioSenderPlayer::factory().autoReg( &create< AudioSenderPlayerv8 >, 10 );
RegHolder vp11 = AudioSenderPlayer::factory().autoReg( &create< AudioSenderPlayerv8 >, 11 );
RegHolder vp12 = AudioSenderPlayer::factory().autoReg( &create< AudioSenderPlayerv8 >, 12 );
RegHolder vp13 = AudioSenderPlayer::factory().autoReg( &create< AudioSenderPlayerv8 >, 13 );

template< typename Sender >
AudioSender::Ptr
create( const AudioSenderCoach::Params & params )
{
    return AudioSender::Ptr( new Sender( params ) );
}

RegHolder vc1 = AudioSenderCoach::factory().autoReg( &create< AudioSenderCoachv1 >, 1 );
RegHolder vc2 = AudioSenderCoach::factory().autoReg( &create< AudioSenderCoachv1 >, 2 );
RegHolder vc3 = AudioSenderCoach::factory().autoReg( &create< AudioSenderCoachv1 >, 3 );
RegHolder vc4 = AudioSenderCoach::factory().autoReg( &create< AudioSenderCoachv1 >, 4 );
RegHolder vc5 = AudioSenderCoach::factory().autoReg( &create< AudioSenderCoachv1 >, 5 );
RegHolder vc6 = AudioSenderCoach::factory().autoReg( &create< AudioSenderCoachv1 >, 6 );
RegHolder vc7 = AudioSenderCoach::factory().autoReg( &create< AudioSenderCoachv7 >, 7 );
RegHolder vc8 = AudioSenderCoach::factory().autoReg( &create< AudioSenderCoachv7 >, 8 );
RegHolder vc9 = AudioSenderCoach::factory().autoReg( &create< AudioSenderCoachv7 >, 9 );
RegHolder vc10 = AudioSenderCoach::factory().autoReg( &create< AudioSenderCoachv7 >, 10 );
RegHolder vc11 = AudioSenderCoach::factory().autoReg( &create< AudioSenderCoachv7 >, 11 );
RegHolder vc12 = AudioSenderCoach::factory().autoReg( &create< AudioSenderCoachv7 >, 12 );
RegHolder vc13 = AudioSenderCoach::factory().autoReg( &create< AudioSenderCoachv7 >, 13 );

template< typename Sender >
AudioSender::Ptr
create( const AudioSenderOnlineCoach::Params & params )
{
    return AudioSender::Ptr( new Sender( params ) );
}

RegHolder voc1 = AudioSenderOnlineCoach::factory().autoReg( &create< AudioSenderOnlineCoachv1 >, 1 );
RegHolder voc2 = AudioSenderOnlineCoach::factory().autoReg( &create< AudioSenderOnlineCoachv1 >, 2 );
RegHolder voc3 = AudioSenderOnlineCoach::factory().autoReg( &create< AudioSenderOnlineCoachv1 >, 3 );
RegHolder voc4 = AudioSenderOnlineCoach::factory().autoReg( &create< AudioSenderOnlineCoachv1 >, 4 );
RegHolder voc5 = AudioSenderOnlineCoach::factory().autoReg( &create< AudioSenderOnlineCoachv1 >, 5 );
RegHolder voc6 = AudioSenderOnlineCoach::factory().autoReg( &create< AudioSenderOnlineCoachv1 >, 6 );
RegHolder voc7 = AudioSenderOnlineCoach::factory().autoReg( &create< AudioSenderOnlineCoachv7 >, 7 );
RegHolder voc8 = AudioSenderOnlineCoach::factory().autoReg( &create< AudioSenderOnlineCoachv7 >, 8 );
RegHolder voc9 = AudioSenderOnlineCoach::factory().autoReg( &create< AudioSenderOnlineCoachv7 >, 9 );
RegHolder voc10 = AudioSenderOnlineCoach::factory().autoReg( &create< AudioSenderOnlineCoachv7 >, 10 );
RegHolder voc11 = AudioSenderOnlineCoach::factory().autoReg( &create< AudioSenderOnlineCoachv7 >, 11 );
RegHolder voc12 = AudioSenderOnlineCoach::factory().autoReg( &create< AudioSenderOnlineCoachv7 >, 12 );
RegHolder voc13 = AudioSenderOnlineCoach::factory().autoReg( &create< AudioSenderOnlineCoachv7 >, 13 );
}
}