audio.cpp

2009 ROBOCUP 仿真2DSERVER 源码

// -*-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.                                                        *
 *                                                                         *
 ***************************************************************************/

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include "audio.h"

#include "clangmsg.h"
#include "clangunsuppmsg.h"
#include "coach.h"
#include "field.h"
#include "player.h"
#include "random.h"
#include "utility.h"
#include "serializer.h"

#include <rcssbase/factory.hpp>

namespace rcss {

void
Listener::sendRefereeAudio( const char * msg )
{
    sender().sendRefereeAudio( 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::FactoryHolder &
AudioSenderPlayer::factory()
{
    static FactoryHolder rval;
    return rval;
}


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

}

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


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.state() != DISABLE;
}

bool
AudioSenderPlayer::coachStdPredicate( const rcss::clang::Msg & msg ) const
{
    return ( generalPredicate()
             && M_listener.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 ( M_listener.canHearFullFrom( player )
             && player.pos().distance( M_listener.pos() )
             <= ServerParam::instance().audioCutDist() )
        {
            return true;
        }
//         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 )
{
    M_listener.decrementHearCapacity( 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::sendRefereeAudio( const char * msg )
{
    if ( generalPredicate () )
    {
        M_serializer.serializeRefereeAudio( 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.clangMinVer(),
                              M_listener.clangMaxVer() ) )
        {
            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.angleFromBody( 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.clangMinVer(),
                                   M_listener.clangMaxVer() );
    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.angleFromBody( player ) );
        M_serializer.serializePlayerAudio( transport(),
                                           M_stadium.time(),
                                           dir,
                                           msg );
        transport() << std::ends << std::flush;
        postNonSelfPlayer( player );
    }
}


AudioSenderPlayerv8::~AudioSenderPlayerv8()
{
    for ( player_msg_cont_t::iterator i = M_player_msgs.begin();
          i != M_player_msgs.end();
          ++i )
    {
        free( i->second );
        i->second = NULL;
    }
    M_player_msgs.clear();

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

    for ( coach_msg_cont_t::iterator i = M_coach_msgs.begin();
          i != M_coach_msgs.end();
          ++i )
    {
        free( i->second );
        i->second = NULL;
    }
    M_coach_msgs.clear();
}

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

bool
AudioSenderPlayerv8::nonSelfPlayerFullPredicate( const Player & player ) const
{
    return M_listener.canHearFullFrom( player );
//     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 )
{
    if ( ! nonSelfPlayerPredicate( player ) )
    {
        return;
    }

    if ( ! M_left_complete
         && ! M_left_partial
         && player.side() == LEFT )
    {
        // if ear off all, messages are never cached
        return;
    }

    if ( ! M_right_complete
         && ! M_right_partial
         && player.side() == RIGHT )
    {
        // if ear off all, messages are never cached
        return;
    }

    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 );