audio.cc

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

// -*-c++-*-

/***************************************************************************
                                   audio.cc  
                    Classes for building audio messages
                             -------------------
    begin                : 27-JAN-2002
    copyright            : (C) 2002 by The RoboCup Soccer Server 
                           Maintenance Group.
    email                : [e-mail]
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU LGPL as published by the Free Software  *
 *   Foundation; either version 2 of the License, or (at your option) any  *
 *   later version.                                                        *
 *                                                                         *
 ***************************************************************************/

#include "audio.h"
#include "serializer.h"
#include "field.h"
#include "player.h"
#include "utility.h"
#include "random.h"
#include "clangmsg.h"
#include "clangunsuppmsg.h"
#include <rcssbase/lib/factory.hpp>

namespace rcss
{
    void 
    Listener::sendRefAudio( const char* msg )
    {
        sender().sendRefAudio( msg );
    }

    void 
    Listener::sendCoachAudio( const Coach& coach,
                              const char* msg )
    {
        sender().sendCoachAudio( coach, msg );
    }

    void 
    Listener::sendCoachStdAudio( const rcss::clang::Msg& msg )
    {
        sender().sendCoachStdAudio( msg );
    }

    void 
    Listener::sendPlayerAudio( const Player& player,
                               const char* msg )
    {
        sender().sendPlayerAudio( player, msg );
    }

    void 
    Listener::newCycle()
    {
        sender().newCycle();
    }

    void
    Listener::focusOn( const Player& player )
    {
        sender().focusOn( player );
    }

    void
    Listener::focusOff()
    {
        sender().focusOff();
    }

    void
    Listener::setEar( bool on, Side side, bool complete, bool partial )
    {
        sender().setEar( on, side, complete, partial );
    }

    void
    Listener::sendOKClang()
    {
        sender().sendOKClang();
    }

    void
    Listener::sendErrorNoTeamName( const std::string& team_name )
    {
        sender().sendErrorNoTeamName( team_name );
    }


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

    void
    AudioSenderPlayer::sendPlayerAudio( const Player& player,
                                        const char* msg )
    {
        if( &player == &M_listener )
        {
            sendSelfAudio( msg );
        }
        else
        {
            sendNonSelfPlayerAudio( player, msg );
        }
    }


    bool 
    AudioSenderPlayer::generalPredicate() const
    {
        return M_listener.alive != DISABLE;
    }

    bool 
    AudioSenderPlayer::coachStdPredicate( const rcss::clang::Msg& msg ) const
    {
        return ( generalPredicate() 
                 && M_listener.team->side == msg.getSide() );
    }


    bool 
    AudioSenderPlayer::nonSelfPlayerPredicate( const Player& player ) const
    {
        // we could do this as one big return statement, but then it becomes
        // a nightmare to understand
        if( generalPredicate() )
        {
            if( player.pos.distance ( M_listener.pos ) 
                <= ServerParam::instance().audio_dist )
            {
                if ( M_listener.team == player.team )
                {
                    return ( M_listener.hear_capacity_from_teammate 
                             >= (int)ServerParam::instance().hearDecay() );
                }
                else
                {
                    return ( M_listener.hear_capacity_from_opponent 
                             >= (int)ServerParam::instance().hearDecay() );
                }
            }
        }
        return false;
    }

    bool 
    AudioSenderPlayer::postNonSelfPlayer( const Player& player )
    {
        if( M_listener.team == player.team )
            M_listener.hear_capacity_from_teammate
                -= ServerParam::instance().hearDecay();
        else
            M_listener.hear_capacity_from_opponent
                -= ServerParam::instance().hearDecay();
        return true;
    }


    void
    AudioSenderPlayerv1::sendRefAudio( const char* msg )
    {
        if( generalPredicate () )
        {
            M_serializer.serializeRefAudio( transport(), M_stadium.time, msg );
            transport() << std::ends << std::flush;
        }
    }


    void
    AudioSenderPlayerv1::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 here so don't send anything
                    return;
            }
            M_serializer.serializeCoachAudio( transport(),
                                              M_stadium.time,
                                              name,
                                              msg );
            transport() << std::ends << std::flush;
        }
    }


    void
    AudioSenderPlayerv1::sendCoachStdAudio( const rcss::clang::Msg& msg )
    {
        if( coachStdPredicate( msg ) )
        {
            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 here so don't send anything
                    return;
            }
            if( msg.isSupported( M_listener.getClangMinVer(),
                                 M_listener.getClangMaxVer() ) )
                M_serializer.serializeCoachStdAudio( transport(),
                                                     msg.getTimeSend(),
                                                     name,
                                                     msg );
            else
                M_serializer.serializeCoachStdAudio( transport(),
                                                     msg.getTimeSend(),
                                                     name, 
                                                     rcss::clang::UnsuppMsg() );
            transport() << std::ends << std::flush;
        }
    }

    void
    AudioSenderPlayerv1::sendSelfAudio( const char* msg )
    {
        if( generalPredicate () )
        {
            M_serializer.serializeSelfAudio( transport(), M_stadium.time, msg );
            transport() << std::ends << std::flush;
        }
    }

    void
    AudioSenderPlayerv1::sendNonSelfPlayerAudio( const Player& player,
                                                 const char* msg )
    {
        if( nonSelfPlayerPredicate( player ) )
        {
            int dir = Rad2IDeg( M_listener.vangle( player ) );
            M_serializer.serializePlayerAudio( transport(),
                                               M_stadium.time,
                                               dir,
                                               msg );
            transport() << std::ends << std::flush;
            postNonSelfPlayer( player );
        }
    }

    void
    AudioSenderPlayerv1::sendOKClang()
    {
        M_serializer.serializeOKClang( transport(),
                                       M_listener.getClangMinVer(),
                                       M_listener.getClangMaxVer() );
        transport() << std::ends << std::flush;
    }

    void
    AudioSenderPlayerv1::sendErrorNoTeamName( const std::string& team_name )
    {
        M_serializer.serializeErrorNoTeamName( transport(), team_name );
        transport() << std::ends << std::flush;
    }

  
    void
    AudioSenderPlayerv7::sendCoachAudio( const Coach& coach,
                                         const char* msg )
    {
        if( generalPredicate() )
        {
            std::string name;
            switch( coach.side )
            {
                case NEUTRAL:
                    name = COACH_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
    AudioSenderPlayerv7::sendNonSelfPlayerAudio( const Player& player,
                                                 const char* msg )
    {
        if( nonSelfPlayerPredicate( player ) )
        {
            int dir = Rad2IDegRound( M_listener.vangle( player ) );
            M_serializer.serializePlayerAudio( transport(),
                                               M_stadium.time, 
                                               dir, 
                                               msg );
            transport() << std::ends << std::flush;
            postNonSelfPlayer( player );
        }
    }

    bool 
    AudioSenderPlayerv8::nonSelfPlayerPredicate( const Player& player ) const
    {
        return ( generalPredicate() 
                 && ( player.pos.distance ( M_listener.pos ) 
                      <= ServerParam::instance().audio_dist ) );
    }

    bool 
    AudioSenderPlayerv8::nonSelfPlayerFullPredicate( const Player& player ) const
    {
        if ( M_listener.team == player.team )
        {
            return ( M_listener.hear_capacity_from_teammate 
                     >= (int)ServerParam::instance().hearDecay() );
        }
        else
        {
            return ( M_listener.hear_capacity_from_opponent 
                     >= (int)ServerParam::instance().hearDecay() );
        }
    }
  

    void
    AudioSenderPlayerv8::sendCoachAudio( const Coach& coach, const char* msg )
    {
        char* msg_copy = strdup( msg );
        if( msg_copy == NULL )
        {
            std::cerr << "Error:  could not alocate memory to cache coach audio message\n";
        }
        else
        {
            M_coach_msgs.push_back( coach_key_value_t( &coach, 
                                                       msg_copy ) );
        }
    }


    void
    AudioSenderPlayerv8::sendSelfAudio( const char* msg )
    {
        char* msg_copy = strdup( msg );
        if( msg_copy == NULL )
        {
            std::cerr << "Error:  could not alocate memory to cache player's own audio message\n";
        }
        else
        {
            M_self_msgs.push_back( msg_copy );
        }
    }


    void
    AudioSenderPlayerv8::sendNonSelfPlayerAudio( const Player& player,
                                                 const char* msg )
    {
        char* msg_copy = strdup( msg );
        if( msg_copy == NULL )
        {
            std::cerr << "Error:  could not alocate memory to cache player audio message\n";
        }
        else
        {
            M_player_msgs.insert( player_key_value_t( &player,
                                                      msg_copy ) );
        }
    }


    void
    AudioSenderPlayerv8::newCycle()
    {
        for( coach_msg_cont_t::iterator i = M_coach_msgs.begin();
             i != M_coach_msgs.end(); ++i )
        {
            sendCachedCoachAudio( *(i->first), i->second );
            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 );