audio.h

2009 ROBOCUP 仿真2DSERVER 源码

    // the containers and pairs below use char* instead of const
    // char* as the strings belong to the containers and pairs and
    // will be deleted after they are removed. By making the
    // non-const, a string needs to be copied to be inserted. I
    // know it's a bit of a dodgy safty check, but it's better
    // than nothing.  I'll try to make it cleaner later.  Idealy
    // we should store them once in a general store and then point
    // to that store.  Then we could just delete from that store
    // when we are done... More work for later.

    typedef const Player* player_key_t;
    typedef std::pair< player_key_t, char* > player_key_value_t;
    typedef const Coach* coach_key_t;
    typedef std::pair< coach_key_t, char* > coach_key_value_t;

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

    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:
        std::ostream & m_transport;
        Coach & m_listener;
        const SerializerCoach & m_serializer;
        const Stadium & m_stadium;

        Params( std::ostream & transport,
                Coach & listener,
                const SerializerCoach & serializer,
                const Stadium & stadium )
            : m_transport( transport )
            , m_listener( listener )
            , m_serializer( serializer )
            , m_stadium( stadium )
          { }
    };

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

    static
    FactoryHolder & factory();


    AudioSenderCoach( const Params & params );

    ~AudioSenderCoach();

protected:
    virtual
    bool generalPredicate() const;
};




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

    virtual
    ~AudioSenderCoachv1()
      { }

    virtual
    void sendRefereeAudio( 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:
        std::ostream & m_transport;
        OnlineCoach & m_listener;
        const SerializerOnlineCoach & m_serializer;
        const Stadium & m_stadium;

        Params( std::ostream & transport,
                OnlineCoach & listener,
                const SerializerOnlineCoach & serializer,
                const Stadium & stadium )
            : m_transport( transport )
            , m_listener( listener )
            , m_serializer( serializer )
            , m_stadium( stadium )
          {}
    };

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

    static
    FactoryHolder & factory();

    AudioSenderOnlineCoach( const Params & params );

    ~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 sendRefereeAudio( 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_