audio_sensor.h

Go to the documentation of this file.

// -*-c++-*-
 
/*
 *Copyright:
 
 Copyright (C) Hidehisa AKIYAMA
 
 This code is free software; you can redistribute it and/or
 modify it under the terms of the GNU Lesser General Public
 License as published by the Free Software Foundation; either
 version 3 of the License, or (at your option) any later version.
 
 This library is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 Lesser General Public License for more details.
 
 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
 *EndCopyright:
 */
 
 
#ifndef RCSC_PLAYER_AUDIO_SENSOR_H
#define RCSC_PLAYER_AUDIO_SENSOR_H
 
#include <rcsc/common/audio_message.h>
#include <rcsc/common/say_message_parser.h>
#include <rcsc/common/freeform_message_parser.h>
#include <rcsc/clang/clang_parser.h>
 
#include <rcsc/game_time.h>
#include <rcsc/types.h>
#include <rcsc/geom/vector_2d.h>
 
#include <string>
#include <unordered_map>
#include <list>
#include <vector>
 
namespace rcsc {
 
/*-------------------------------------------------------------------*/
class AudioSensor {
private:
 
    typedef std::unordered_map< char, SayMessageParser::Ptr > ParserMap;
    typedef std::unordered_map< std::string, FreeformMessageParser::Ptr > FreeformParserMap;
 
    ParserMap M_say_message_parsers;
 
    FreeformParserMap M_freeform_parsers;
 
    GameTime M_teammate_message_time;
 
    std::list< HearMessage > M_teammate_messages;
 
    GameTime M_opponent_message_time;
 
    std::list< HearMessage > M_opponent_messages;
 
    GameTime M_freeform_message_time;
 
    std::string M_freeform_message;
 
    GameTime M_trainer_message_time;
 
    std::string M_trainer_message;
 
    GameTime M_clang_time;
 
    std::string M_clang_message;
 
    CLangParser M_clang_parser;
 
public:
    AudioSensor();
 
    void addSayMessageParser( SayMessageParser::Ptr parser );
 
    void removeSayMessageParser( const char header );
 
    void addFreeformMessageParser( FreeformMessageParser::Ptr parser );
 
    void removeFreeformMessageParser( const std::string & type );
 
    void parsePlayerMessage( const char * msg,
                             const GameTime & current );
 
    void parseCoachMessage( const char * msg,
                            const GameTime & current );
 
    void parseTrainerMessage( const char * msg,
                              const GameTime & current );
 
    const GameTime & teammateMessageTime() const
      {
          return M_teammate_message_time;
      }
 
    const std::list< HearMessage > & teammateMessages() const
      {
          return M_teammate_messages;
      }
 
    const GameTime & opponentMessageTime() const
      {
          return M_opponent_message_time;
      }
 
    const std::list< HearMessage > & opponentMessages() const
      {
          return M_opponent_messages;
      }
 
    const
    GameTime & freeformMessageTime() const
      {
          return M_freeform_message_time;
      }
 
    const std::string & freeformMessage() const
      {
          return M_freeform_message;
      }
 
    const GameTime & trainerMessageTime() const
      {
          return M_trainer_message_time;
      }
 
    const std::string & trainerMessage() const
      {
          return M_trainer_message;
      }
 
    const GameTime & clangTime() const
      {
          return M_clang_time;
 
      }
 
    const std::string & clangMessage() const
      {
          return M_clang_message;
      }
 
    const CLangParser & clangParser() const
      {
          return M_clang_parser;
      }
 
private:
    /*
      \brief analyze message from teammate
      \param message message object from teammate
    */
    void parseTeammateMessage( const HearMessage & message );
 
    void buildFreeformMessage( const char * msg );
 
    bool parseFreeformMessage();
 
 
    void buildCLangMessage( const char * msg );
 
    bool parseCLangMessage();
 
};
 
}
 
#endif