audio.cc

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

            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.team->side == LEFT && M_left_complete )
                    || ( player.team->side == RIGHT && M_right_complete ) )
                {
                    int dir = Rad2IDeg( M_listener.vangle( 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.team->side == LEFT && M_left_partial )
                    || ( player.team->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< rcss::random::DefaultRNG > rand_int( rcss::random::DefaultRNG::instance(),
                                                                          0, msgs.size () - 1 );
            int idx = rand_int();
            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 )
    {
        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 != msgs.end(); ++i )
        {
            if( i->first != M_key )
            {
                iters.second = i;
                break;
            }         
        }
  
        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< rcss::random::DefaultRNG > rand_int( rcss::random::DefaultRNG::instance(),
                                                                      0, count - 1 );
      
        int idx = rand_int();
        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::Factory&
    AudioSenderCoach::factory()
    { static Factory rval; return rval; }

    bool
    AudioSenderCoach::generalPredicate() const
    {
        return ( ( ServerParam::instance().CoachMode 
                   || ServerParam::instance().CwRMode ) 
                 && M_listener.hear );
    }



    void
    AudioSenderCoachv1::sendRefAudio( const char* msg )
    {
        if( generalPredicate() )
        {
            M_serializer.serializeRefAudio( 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.short_name,
                                               msg );
            transport() << std::ends << std::flush;
        }
    }


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

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

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


    void
    AudioSenderOnlineCoachv1::sendRefAudio( const char* msg )
    {
        if( generalPredicate() )
        {
            M_serializer.serializeRefAudio( 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.serializeRefAudio ( 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.short_name,
                                               msg );
            transport() << std::ends << std::flush;
        }
    }

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

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

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


        lib::RegHolder vp1 = AudioSenderPlayer::factory().autoReg( &create< AudioSenderPlayerv1 >, 1 );
        lib::RegHolder vp2 = AudioSenderPlayer::factory().autoReg( &create< AudioSenderPlayerv1 >, 2 );
        lib::RegHolder vp3 = AudioSenderPlayer::factory().autoReg( &create< AudioSenderPlayerv1 >, 3 );
        lib::RegHolder vp4 = AudioSenderPlayer::factory().autoReg( &create< AudioSenderPlayerv1 >, 4 );
        lib::RegHolder vp5 = AudioSenderPlayer::factory().autoReg( &create< AudioSenderPlayerv1 >, 5 );
        lib::RegHolder vp6 = AudioSenderPlayer::factory().autoReg( &create< AudioSenderPlayerv1 >, 6 );
        lib::RegHolder vp7 = AudioSenderPlayer::factory().autoReg( &create< AudioSenderPlayerv7 >, 7 );
        lib::RegHolder vp8 = AudioSenderPlayer::factory().autoReg( &create< AudioSenderPlayerv8 >, 8 );
        lib::RegHolder vp9 = AudioSenderPlayer::factory().autoReg( &create< AudioSenderPlayerv8 >, 9 );
        
        lib::RegHolder vc1 = AudioSenderCoach::factory().autoReg( &create< AudioSenderCoachv1 >, 1 );
        lib::RegHolder vc2 = AudioSenderCoach::factory().autoReg( &create< AudioSenderCoachv1 >, 2 );
        lib::RegHolder vc3 = AudioSenderCoach::factory().autoReg( &create< AudioSenderCoachv1 >, 3 );
        lib::RegHolder vc4 = AudioSenderCoach::factory().autoReg( &create< AudioSenderCoachv1 >, 4 );
        lib::RegHolder vc5 = AudioSenderCoach::factory().autoReg( &create< AudioSenderCoachv1 >, 5 );
        lib::RegHolder vc6 = AudioSenderCoach::factory().autoReg( &create< AudioSenderCoachv1 >, 6 );
        lib::RegHolder vc7 = AudioSenderCoach::factory().autoReg( &create< AudioSenderCoachv7 >, 7 );
        lib::RegHolder vc8 = AudioSenderCoach::factory().autoReg( &create< AudioSenderCoachv7 >, 8 );
        lib::RegHolder vc9 = AudioSenderCoach::factory().autoReg( &create< AudioSenderCoachv7 >, 9 );
     
        lib::RegHolder voc1 = AudioSenderOnlineCoach::factory().autoReg( &create< AudioSenderOnlineCoachv1 >, 1 );
        lib::RegHolder voc2 = AudioSenderOnlineCoach::factory().autoReg( &create< AudioSenderOnlineCoachv1 >, 2 );
        lib::RegHolder voc3 = AudioSenderOnlineCoach::factory().autoReg( &create< AudioSenderOnlineCoachv1 >, 3 );
        lib::RegHolder voc4 = AudioSenderOnlineCoach::factory().autoReg( &create< AudioSenderOnlineCoachv1 >, 4 );
        lib::RegHolder voc5 = AudioSenderOnlineCoach::factory().autoReg( &create< AudioSenderOnlineCoachv1 >, 5 );
        lib::RegHolder voc6 = AudioSenderOnlineCoach::factory().autoReg( &create< AudioSenderOnlineCoachv1 >, 6 );
        lib::RegHolder voc7 = AudioSenderOnlineCoach::factory().autoReg( &create< AudioSenderOnlineCoachv7 >, 7 );
        lib::RegHolder voc8 = AudioSenderOnlineCoach::factory().autoReg( &create< AudioSenderOnlineCoachv7 >, 8 );
        lib::RegHolder voc9 = AudioSenderOnlineCoach::factory().autoReg( &create< AudioSenderOnlineCoachv7 >, 9 );
    }
}