say_message_parser.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_COMMON_SAY_MESSAGE_PARSER_H
#define RCSC_COMMON_SAY_MESSAGE_PARSER_H
 
#include <rcsc/types.h>
 
#include <memory>
#include <string>
 
namespace rcsc {
 
class AudioMemory;
class GameTime;
 
/*-------------------------------------------------------------------*/
class SayMessageParser {
public:
 
    typedef std::shared_ptr< SayMessageParser > Ptr;
 
private:
 
    // not used
    SayMessageParser( const SayMessageParser & ) = delete;
    SayMessageParser & operator=( const SayMessageParser & ) = delete;
 
protected:
 
    SayMessageParser() = default;
 
public:
 
    virtual
    ~SayMessageParser() = default;
 
    virtual
    char header() const = 0;
 
    virtual
    int parse( const int sender,
               const double & dir,
               const char * msg,
               const GameTime & current ) = 0;
 
};
 
/*-------------------------------------------------------------------*/
class BallMessageParser
    : public SayMessageParser {
private:
 
    std::shared_ptr< AudioMemory > M_memory;
 
public:
 
    explicit
    BallMessageParser( std::shared_ptr< AudioMemory > memory );
 
    static
    char sheader() { return 'b'; }
 
    char header() const { return sheader(); }
 
    static
    int slength() { return 6; }
 
    int parse( const int sender,
               const double & dir,
               const char * msg,
               const GameTime & current );
 
};
 
/*-------------------------------------------------------------------*/
class PassMessageParser
    : public SayMessageParser {
private:
 
    std::shared_ptr< AudioMemory > M_memory;
 
public:
 
    explicit
    PassMessageParser( std::shared_ptr< AudioMemory > memory );
 
    static
    char sheader() { return 'p'; }
 
    char header() const { return sheader(); }
 
    static
    int slength() { return 10; }
 
    int parse( const int sender,
               const double & dir,
               const char * msg,
               const GameTime & current );
 
};
 
/*-------------------------------------------------------------------*/
class InterceptMessageParser
    : public SayMessageParser {
private:
 
    std::shared_ptr< AudioMemory > M_memory;
 
public:
 
    explicit
    InterceptMessageParser( std::shared_ptr< AudioMemory > memory );
 
    static
    char sheader() { return 'i'; }
 
    char header() const { return sheader(); }
 
    static
    int slength() { return 3; }
 
    int parse( const int sender,
               const double & dir,
               const char * msg,
               const GameTime & current );
 
};
 
/*-------------------------------------------------------------------*/
class GoalieMessageParser
    : public SayMessageParser {
private:
 
    std::shared_ptr< AudioMemory > M_memory;
 
public:
 
    explicit
    GoalieMessageParser( std::shared_ptr< AudioMemory > memory );
 
    static
    char sheader() { return 'g'; }
 
    char header() const { return sheader(); }
 
    static
    int slength() { return 5; }
 
    int parse( const int sender,
               const double & dir,
               const char * msg,
               const GameTime & current );
 
};
 
 
/*-------------------------------------------------------------------*/
class GoalieAndPlayerMessageParser
    : public SayMessageParser {
private:
 
    std::shared_ptr< AudioMemory > M_memory;
 
public:
 
    explicit
    GoalieAndPlayerMessageParser( std::shared_ptr< AudioMemory > memory );
 
    static
    char sheader() { return 'e'; }
 
    char header() const { return sheader(); }
 
    static
    int slength() { return 8; }
 
    int parse( const int sender,
               const double & dir,
               const char * msg,
               const GameTime & current );
 
};
 
 
/*-------------------------------------------------------------------*/
class OffsideLineMessageParser
    : public SayMessageParser {
private:
 
    std::shared_ptr< AudioMemory > M_memory;
 
public:
 
    explicit
    OffsideLineMessageParser( std::shared_ptr< AudioMemory > memory );
 
    static
    char sheader() { return 'o'; }
 
    char header() const { return sheader(); }
 
    static
    int slength() { return 2; }
 
    int parse( const int sender,
               const double & dir,
               const char * msg,
               const GameTime & current );
 
};
 
/*-------------------------------------------------------------------*/
class DefenseLineMessageParser
    : public SayMessageParser {
private:
 
    std::shared_ptr< AudioMemory > M_memory;
 
public:
 
    explicit
    DefenseLineMessageParser( std::shared_ptr< AudioMemory > memory );
 
    static
    char sheader() { return 'd'; }
 
    char header() const { return sheader(); }
 
    static
    int slength() { return 2; }
 
    int parse( const int sender,
               const double & dir,
               const char * msg,
               const GameTime & current );
 
};
 
/*-------------------------------------------------------------------*/
class WaitRequestMessageParser
    : public SayMessageParser {
private:
 
    std::shared_ptr< AudioMemory > M_memory;
 
public:
 
    explicit
    WaitRequestMessageParser( std::shared_ptr< AudioMemory > memory );
 
    static
    char sheader() { return 'w'; }
 
    char header() const { return sheader(); }
 
    static
    int slength() { return 1; }
 
    int parse( const int sender,
               const double & dir,
               const char * msg,
               const GameTime & current );
 
};
 
/*-------------------------------------------------------------------*/
class SetplayMessageParser
    : public SayMessageParser {
private:
 
    std::shared_ptr< AudioMemory > M_memory;
 
public:
 
    explicit
    SetplayMessageParser( std::shared_ptr< AudioMemory > memory );
 
    static
    char sheader() { return 'F'; }
 
    char header() const { return sheader(); }
 
    static
    int slength() { return 2; }
 
    int parse( const int sender,
               const double & dir,
               const char * msg,
               const GameTime & current );
 
};
 
/*-------------------------------------------------------------------*/
class PassRequestMessageParser
    : public SayMessageParser {
private:
 
    std::shared_ptr< AudioMemory > M_memory;
 
public:
 
    explicit
    PassRequestMessageParser( std::shared_ptr< AudioMemory > memory );
 
    static
    char sheader() { return 'h'; }
 
    char header() const { return sheader(); }
 
    static
    int slength() { return 4; }
 
    int parse( const int sender,
               const double & dir,
               const char * msg,
               const GameTime & current );
 
};
 
/*-------------------------------------------------------------------*/
class StaminaMessageParser
    : public SayMessageParser {
private:
 
    std::shared_ptr< AudioMemory > M_memory;
 
public:
 
    explicit
    StaminaMessageParser( std::shared_ptr< AudioMemory > memory );
 
    static
    char sheader() { return 's'; }
 
    char header() const { return sheader(); }
 
    static
    int slength() { return 2; }
 
    int parse( const int sender,
               const double & dir,
               const char * msg,
               const GameTime & current );
 
};
 
/*-------------------------------------------------------------------*/
class RecoveryMessageParser
    : public SayMessageParser {
private:
 
    std::shared_ptr< AudioMemory > M_memory;
 
public:
 
    explicit
    RecoveryMessageParser( std::shared_ptr< AudioMemory > memory );
 
    static
    char sheader() { return 'r'; }
 
    char header() const { return sheader(); }
 
    static
    int slength() { return 2; }
 
    int parse( const int sender,
               const double & dir,
               const char * msg,
               const GameTime & current );
 
};
 
/*-------------------------------------------------------------------*/
class StaminaCapacityMessageParser
    : public SayMessageParser {
private:
 
    std::shared_ptr< AudioMemory > M_memory;
 
public:
 
    explicit
    StaminaCapacityMessageParser( std::shared_ptr< AudioMemory > memory );
 
    static
    char sheader() { return 'c'; }
 
    char header() const { return sheader(); }
 
    static
    int slength() { return 2; }
 
    int parse( const int sender,
               const double & dir,
               const char * msg,
               const GameTime & current );
 
};
 
/*-------------------------------------------------------------------*/
class DribbleMessageParser
    : public SayMessageParser {
private:
 
    std::shared_ptr< AudioMemory > M_memory;
 
public:
 
    explicit
    DribbleMessageParser( std::shared_ptr< AudioMemory > memory );
 
    static
    char sheader() { return 'D'; }
 
    char header() const { return sheader(); }
 
    static
    int slength() { return 4; }
 
    int parse( const int sender,
               const double & dir,
               const char * msg,
               const GameTime & current );
 
};
 
/*-------------------------------------------------------------------*/
class BallGoalieMessageParser
    : public SayMessageParser {
private:
 
    std::shared_ptr< AudioMemory > M_memory;
 
public:
 
    explicit
    BallGoalieMessageParser( std::shared_ptr< AudioMemory > memory );
 
    static
    char sheader() { return 'G'; }
 
    char header() const { return sheader(); }
 
    static
    int slength() { return 10; }
 
    int parse( const int sender,
               const double & dir,
               const char * msg,
               const GameTime & current );
 
};
 
/*-------------------------------------------------------------------*/
class OnePlayerMessageParser
    : public SayMessageParser {
private:
 
    std::shared_ptr< AudioMemory > M_memory;
 
public:
 
    explicit
    OnePlayerMessageParser( std::shared_ptr< AudioMemory > memory );
 
    static
    char sheader() { return 'P'; }
 
    char header() const { return sheader(); }
 
    static
    int slength() { return 4; }
 
    int parse( const int sender,
               const double & dir,
               const char * msg,
               const GameTime & current );
 
};
 
/*-------------------------------------------------------------------*/
class TwoPlayerMessageParser
    : public SayMessageParser {
private:
 
    std::shared_ptr< AudioMemory > M_memory;
 
public:
 
    explicit
    TwoPlayerMessageParser( std::shared_ptr< AudioMemory > memory );
 
    static
    char sheader() { return 'Q'; }
 
    char header() const { return sheader(); }
 
    static
    int slength() { return 7; }
 
    int parse( const int sender,
               const double & dir,
               const char * msg,
               const GameTime & current );
 
};
 
/*-------------------------------------------------------------------*/
class ThreePlayerMessageParser
    : public SayMessageParser {
private:
 
    std::shared_ptr< AudioMemory > M_memory;
 
public:
 
    explicit
    ThreePlayerMessageParser( std::shared_ptr< AudioMemory > memory );
 
    static
    char sheader() { return 'R'; }
 
    char header() const { return sheader(); }
 
    static
    int slength() { return 10; }
 
    int parse( const int sender,
               const double & dir,
               const char * msg,
               const GameTime & current );
 
};
 
/*-------------------------------------------------------------------*/
class SelfMessageParser
    : public SayMessageParser {
private:
 
    std::shared_ptr< AudioMemory > M_memory;
 
public:
 
    explicit
    SelfMessageParser( std::shared_ptr< AudioMemory > memory );
 
    static
    char sheader() { return 'S'; }
 
    char header() const { return sheader(); }
 
    static
    int slength() { return 5; }
 
    int parse( const int sender,
               const double & dir,
               const char * msg,
               const GameTime & current );
 
};
 
/*-------------------------------------------------------------------*/
class TeammateMessageParser
    : public SayMessageParser {
private:
 
    std::shared_ptr< AudioMemory > M_memory;
 
public:
 
    explicit
    TeammateMessageParser( std::shared_ptr< AudioMemory > memory );
 
    static
    char sheader() { return 'T'; }
 
    char header() const { return sheader(); }
 
    static
    int slength() { return 5; }
 
    int parse( const int sender,
               const double & dir,
               const char * msg,
               const GameTime & current );
 
};
 
/*-------------------------------------------------------------------*/
class OpponentMessageParser
    : public SayMessageParser {
private:
 
    std::shared_ptr< AudioMemory > M_memory;
 
public:
 
    explicit
    OpponentMessageParser( std::shared_ptr< AudioMemory > memory );
 
    static
    char sheader() { return 'O'; }
 
    char header() const { return sheader(); }
 
    static
    int slength() { return 5; }
 
    int parse( const int sender,
               const double & dir,
               const char * msg,
               const GameTime & current );
 
};
 
/*-------------------------------------------------------------------*/
class BallPlayerMessageParser
    : public SayMessageParser {
private:
 
    std::shared_ptr< AudioMemory > M_memory;
 
public:
 
    explicit
    BallPlayerMessageParser( std::shared_ptr< AudioMemory > memory );
 
    static
    char sheader() { return 'B'; }
 
    char header() const { return sheader(); }
 
    static
    int slength() { return 10; }
 
    int parse( const int sender,
               const double & dir,
               const char * msg,
               const GameTime & current );
 
};
 
}
 
#endif