audio.h

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

        typedef std::multimap< player_key_t, char* >  player_msg_cont_t;
        typedef std::list< char* >                    self_msg_cont_t;
        typedef std::list< coach_key_value_t >               coach_msg_cont_t;

        class State
        {
        public:
            typedef AudioSenderPlayerv8::player_key_t               key_t;
            typedef AudioSenderPlayerv8::player_msg_cont_t          msg_cont_t;
            typedef AudioSenderPlayerv8::player_key_value_t         key_value_t;

            State() {}

            virtual 
            ~State() {}
    
            virtual 
            key_value_t
            getMsg( msg_cont_t& msgs ) = 0;

            virtual
            const Player*
            getFocusTarget() const
            { return NULL; }
        };

        class Unfocused
            : public State
        {
        public:
            Unfocused() {}

            virtual
            ~Unfocused() {}
   
            virtual
            key_value_t
            getMsg( msg_cont_t& msgs );
        };

        class Focused
            : public Unfocused
        {
        protected:
            player_key_t M_key;
        public:
            Focused()
                : M_key( NULL )
            {}

            virtual 
            ~Focused() {}

            virtual
            void 
            focusOn( const player_key_t& key )
            {
                M_key = key;
            }

            virtual
            key_value_t
            getMsg( msg_cont_t& msgs );

            virtual
            player_key_t
            getFocusTarget() const
            { return M_key; }
        };

        // since we might be switching back and forth between being focused
        // or unfocused, both states are created on the construction of
        // PlayerEar rather than creating them on demand and destroying them
        // when we are finished with them. 
        Unfocused M_unfocused;
        Focused M_focused;

        State* M_state_p;
        unsigned int M_focus_count;

        player_msg_cont_t M_player_msgs;
        self_msg_cont_t   M_self_msgs;
        coach_msg_cont_t  M_coach_msgs;

        bool M_left_partial;
        bool M_left_complete;
        bool M_right_partial;
        bool M_right_complete;

    public:
        AudioSenderPlayerv8( const Params& params )
            : AudioSenderPlayerv7( params ),
              M_state_p( &M_unfocused ),
              M_focus_count ( 0 ),
              M_left_partial( false ),
              M_left_complete( true ),
              M_right_partial( false ),
              M_right_complete( true )
        {}

        virtual
        ~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();
        }

        virtual
        void
        sendCoachAudio( const Coach& coach, const char* msg );

        virtual
        void
        sendSelfAudio( const char* msg );

        virtual
        void
        sendNonSelfPlayerAudio( const Player& player, const char* msg );

        virtual
        void
        newCycle();

        virtual
        void
        focusOn( const Player& player );

        virtual
        void
        focusOff();

        virtual
        const Player*
        getFocusTarget() const
        {
            return M_state_p->getFocusTarget();
        }

        virtual
        unsigned int
        getFocusCount() const
        { return M_focus_count; }

        virtual
        void
        setEar( bool on, Side side, bool complete, bool partial );

    protected:
        virtual
        void
        sendCachedCoachAudio( const Coach& coach, const char* msg );

        virtual
        void
        sendCachedSelfAudio( const char* msg );

        virtual
        void
        sendCachedNonSelfPlayerAudio( const Player& player, const char* msg );

        virtual
        bool 
        nonSelfPlayerPredicate( const Player& player ) const;

        virtual
        bool 
        nonSelfPlayerFullPredicate( const Player& player ) const;

    };


    class SerializerCoach;
    

    class AudioSenderCoach
        : public AudioSender
    {
    protected:
        Coach& M_listener;
        const SerializerCoach& M_serializer;
    public:
        class Params
        {
        public:
            Params( const Stadium& stadium,
                    std::ostream& transport,
                    Coach& listener,
                    const SerializerCoach& serializer )
                : m_stadium( stadium ),
                  m_transport( transport ),
                  m_listener( listener ),
                  m_serializer( serializer )
            {}

            const Stadium& m_stadium;
            std::ostream& m_transport;
            Coach& m_listener;
            const SerializerCoach& m_serializer;
        };

    public:
        typedef Ptr(*Creator)( const Params& );
        typedef rcss::lib::Factory< Creator, int > Factory;

        static
        Factory&
        factory();


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

        ~AudioSenderCoach() {}

    protected:
        virtual
        bool
        generalPredicate() const;
    };




    class AudioSenderCoachv1
        : public AudioSenderCoach
    {
    public:
        AudioSenderCoachv1( const Params& params )
            : AudioSenderCoach( params )
        {}

        virtual
        ~AudioSenderCoachv1()
        {}

        virtual
        void
        sendRefAudio( const char* msg );

        virtual
        void
        sendCoachAudio( const Coach& coach, const char* msg );

        virtual
        void
        sendCoachStdAudio( const clang::Msg& msg );

        virtual
        void
        sendPlayerAudio( const Player& player, const char* msg );
    };




    class AudioSenderCoachv7
        : public AudioSenderCoachv1
    {
    public:
        AudioSenderCoachv7( const Params& params )
            : AudioSenderCoachv1( params )
        {}

        virtual
        ~AudioSenderCoachv7()
        {}

        virtual
        void
        sendPlayerAudio( const Player& player, const char* msg );
    };

    class SerializerOnlineCoach;

    class AudioSenderOnlineCoach
        : public AudioSender
    {
    protected:
        OnlineCoach& M_listener;
        const SerializerOnlineCoach& M_serializer;
    public:
        class Params
        {
        public:
            Params( const Stadium& stadium,
                    std::ostream& transport,
                    OnlineCoach& listener,
                    const SerializerOnlineCoach& serializer )
                : m_stadium( stadium ),
                  m_transport( transport ),
                  m_listener( listener ),
                  m_serializer( serializer )
            {}

            const Stadium& m_stadium;
            std::ostream& m_transport;
            OnlineCoach& m_listener;
            const SerializerOnlineCoach& m_serializer;
        };

    public:
        typedef Ptr(*Creator)( const rcss::AudioSenderOnlineCoach::Params& );
        typedef rcss::lib::Factory< Creator, int > Factory;

        static
        Factory&
        factory();

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

        ~AudioSenderOnlineCoach() {}

    protected:
        virtual
        bool
        generalPredicate() const;

        virtual
        bool
        coachPredicate( const Coach& coach ) const;

    };

    class AudioSenderOnlineCoachv1
        : public AudioSenderOnlineCoach
    {
    public:
        AudioSenderOnlineCoachv1( const Params& params )
            : AudioSenderOnlineCoach( params )
        {}

        virtual
        ~AudioSenderOnlineCoachv1()
        {}

        virtual
        void
        sendRefAudio( const char* msg );

        virtual
        void
        sendCoachAudio( const Coach& coach, const char* msg );

        virtual
        void
        sendPlayerAudio( const Player& player, const char* msg );
    };

    class AudioSenderOnlineCoachv7
        : public AudioSenderOnlineCoachv1
    {
    public:
        AudioSenderOnlineCoachv7( const Params& params )
            : AudioSenderOnlineCoachv1( params )
        {}

        virtual
        ~AudioSenderOnlineCoachv7()
        {}

        virtual
        void
        sendPlayerAudio( const Player& player, const char* msg );
    };
}

#endif // _AUDIO_H_