player_command.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_COMMAND_H
#define RCSC_PLAYER_COMMAND_H
 
#include <rcsc/player/view_mode.h>
#include <rcsc/geom/vector_2d.h>
#include <rcsc/geom/angle_deg.h>
 
#include <string>
#include <iostream>
#include <cmath>
 
namespace rcsc {
 
class PlayerCommand {
public:
    enum Type {
        // connection commands
        INIT, 
        RECONNECT, 
        BYE, 
        // base commands
        MOVE,
        DASH,
        TURN,
        KICK,
        CATCH,
        TACKLE,
        // support commands
        TURN_NECK,
        CHANGE_VIEW,
        CHANGE_FOCUS,
        SAY,
        POINTTO,
        ATTENTIONTO,
        // mode change commands
        CLANG,
        EAR,
        // other commands
        SENSE_BODY,
        SCORE,
        COMPRESSION,
        // synch_mode command
        DONE,
 
        ILLEGAL
    };
 
protected:
    PlayerCommand()
      { }
 
public:
    virtual
    ~PlayerCommand()
      { }
 
    virtual
    Type type() const = 0;
 
    virtual
    std::ostream & toCommandString( std::ostream & to ) const = 0;
 
    virtual
    std::string name() const = 0;
};
 
 
 
class PlayerInitCommand
    : public PlayerCommand {
private:
    std::string M_team_name; 
    double M_version; 
    bool M_goalie; 
public:
    explicit
    PlayerInitCommand( const std::string & team_name,
                       const double & version = 3.0,
                       const bool goalie = false );
 
    Type type() const
      {
          return INIT;
      }
 
    std::ostream & toCommandString( std::ostream & to ) const;
 
    std::string name() const
      {
          return std::string( "init" );
      }
};
 
 
 
class PlayerReconnectCommand
    : public PlayerCommand {
private:
    std::string M_team_name; 
    int M_unum; 
public:
    PlayerReconnectCommand( const std::string & team_name,
                            const int unum );
 
    Type type() const
      {
          return RECONNECT;
      }
 
    std::ostream & toCommandString( std::ostream & to ) const;
 
    std::string name() const
      {
          return std::string( "reconnect" );
      }
};
 
 
 
class PlayerByeCommand
    : public PlayerCommand {
private:
 
public:
    PlayerByeCommand();
 
    Type type() const
      {
          return BYE;
      }
 
    std::ostream & toCommandString( std::ostream & to ) const;
 
    std::string name() const
      {
          return std::string( "bye" );
      }
};
 
 
class PlayerBodyCommand
    : public PlayerCommand {
protected:
    PlayerBodyCommand()
      { }
 
public:
    virtual
    ~PlayerBodyCommand()
      { }
 
    virtual
    Type type() const = 0;
 
    virtual
    std::ostream & toCommandString( std::ostream & to ) const = 0;
 
    virtual
    std::string name() const = 0;
 
};
 
 
class PlayerMoveCommand
    : public PlayerBodyCommand {
private:
    double M_x; 
    double M_y; 
public:
    PlayerMoveCommand( const double & x,
                       const double & y )
        : M_x( x )
        , M_y( y )
      { }
 
    Type type() const
      {
          return MOVE;
      }
 
    std::ostream & toCommandString( std::ostream & to ) const;
 
    std::string name() const
      {
          return std::string( "move" );
      }
 
    Vector2D movePos() const
      {
          return Vector2D( M_x, M_y );
      }
 
};
 
 
class PlayerDashCommand
    : public PlayerBodyCommand {
private:
    double M_power; 
    double M_dir; 
public:
    explicit
    PlayerDashCommand( const double & power,
                       const double & dir = 0.0 )
        : M_power( power )
        , M_dir( dir )
      { }
 
    Type type() const
      {
          return DASH;
      }
 
    std::ostream & toCommandString( std::ostream & to ) const;
 
    std::string name() const
      {
          return std::string( "dash" );
      }
 
    double dashPower() const
      {
          return M_power;
      }
 
    double dashDir() const
      {
          return M_dir;
      }
};
 
 
class PlayerTurnCommand
    : public PlayerBodyCommand {
private:
    double M_moment; 
public:
    explicit
    PlayerTurnCommand( const double & moment )
        : M_moment( moment )
      { }
 
    Type type() const
      {
          return TURN;
      }
 
    std::ostream & toCommandString( std::ostream & to ) const;
 
    std::string name() const
      {
          return std::string( "turn" );
      }
 
    double turnMoment() const
      {
          return M_moment;
      }
};
 
 
 
class PlayerKickCommand
    : public PlayerBodyCommand {
private:
    double M_power; 
    double M_dir; 
public:
    PlayerKickCommand( const double & power,
                       const double & dir )
        : M_power( power )
        , M_dir( dir )
      { }
 
    Type type() const
      {
          return KICK;
      }
 
    std::ostream & toCommandString( std::ostream & to ) const;
 
    std::string name() const
      {
          return std::string( "kick" );
      }
 
    double kickPower() const
      {
          return M_power;
      }
 
    double kickDir() const
      {
          return M_dir;
      }
};
 
 
class PlayerCatchCommand
    : public PlayerBodyCommand {
private:
    double M_dir; 
public:
    explicit
    PlayerCatchCommand( const double & rel_dir )
        : M_dir( rel_dir )
      { }
 
    Type type() const
      {
          return CATCH;
      }
 
    std::ostream & toCommandString( std::ostream & to ) const;
 
    std::string name() const
      {
          return std::string( "catch" );
      }
 
    double catchDir() const
      {
          return M_dir;
      }
};
 
 
class PlayerTackleCommand
    : public PlayerBodyCommand {
private:
    double M_power_or_dir; 
    bool M_foul; 
public:
    explicit
    PlayerTackleCommand( const double & power_or_dir )
        : M_power_or_dir( power_or_dir ),
          M_foul( false )
      { }
 
    PlayerTackleCommand( const double & power_or_dir,
                         const bool foul )
        : M_power_or_dir( power_or_dir ),
          M_foul( foul )
      { }
 
    Type type() const
      {
          return TACKLE;
      }
 
    std::ostream & toCommandString( std::ostream & to ) const;
 
    std::string name() const
      {
          return std::string( "tackle" );
      }
 
    double tacklePowerOrDir() const
      {
          return M_power_or_dir;
      }
 
    bool tackleFoul() const
      {
          return M_foul;
      }
};
 
 
class PlayerSupportCommand
    : public PlayerCommand {
protected:
    PlayerSupportCommand()
      { }
 
public:
    virtual
    ~PlayerSupportCommand()
      { }
 
    virtual
    Type type() const = 0;
 
    virtual
    std::ostream & toCommandString( std::ostream & to ) const = 0;
 
    virtual
    std::string name() const = 0;
};
 
 
class PlayerTurnNeckCommand
    : public PlayerSupportCommand {
private:
    double M_moment; 
public:
    explicit
    PlayerTurnNeckCommand( const double & moment )
        : M_moment( moment )
      { }
 
    Type type() const
      {
          return TURN_NECK;
      }
 
    std::ostream & toCommandString( std::ostream & to ) const;
 
    std::string name() const
      {
          return std::string( "turn_neck" );
      }
 
    const
    double & moment() const
      {
          return M_moment;
      }
};
 
 
class PlayerChangeViewCommand
    : public PlayerSupportCommand {
private:
    ViewWidth M_width; 
    ViewQuality M_quality; 
public:
    PlayerChangeViewCommand( const ViewWidth & w,
                             const ViewQuality & q )
        : M_width( w )
        , M_quality( q )
      { }
 
    Type type() const
      {
          return CHANGE_VIEW;
      }
 
    std::ostream & toCommandString( std::ostream & to ) const;
 
    std::string name() const
      {
          return std::string( "change_view" );
      }
 
    const
    ViewWidth & width() const
      {
          return M_width;
      }
 
    const
    ViewQuality & quality() const
      {
          return M_quality;
      }
};
 
 
class PlayerChangeFocusCommand
    : public PlayerSupportCommand {
private:
    double M_moment_dist; 
    double M_moment_dir; 
 
    PlayerChangeFocusCommand() = delete; // not used
public:
 
    PlayerChangeFocusCommand( const double moment_dist,
                              const double moment_dir )
        : M_moment_dist( moment_dist ),
          M_moment_dir( moment_dir )
      { }
 
    Type type() const
      {
          return CHANGE_FOCUS;
      }
 
    std::ostream & toCommandString( std::ostream & to ) const;
 
    std::string name() const
      {
          return std::string( "change_focus" );
      }
 
    double momentDist() const
      {
          return M_moment_dist;
      }
 
    double momentDir() const
      {
          return M_moment_dir;
      }
 
};
 
 
class PlayerSayCommand
    : public PlayerSupportCommand {
private:
    std::string M_message; 
    double M_version; 
public:
 
    explicit
    PlayerSayCommand( const double & version )
        : M_version( version )
      { }
 
    PlayerSayCommand( const char * msg,
                      const double & version )
        : M_message( msg )
        , M_version( version )
      { }
    PlayerSayCommand( const std::string & msg,
                      const double & version )
        : M_message( msg )
        , M_version( version )
      { }
 
    Type type() const
      {
          return SAY;
      }
 
    std::ostream & toCommandString( std::ostream & to ) const;
 
    std::string name() const
      {
          return std::string( "say" );
      }
 
    void assign( const std::string & msg )
      {
          M_message = msg;
      }
 
    void append( const std::string & msg )
      {
          M_message += msg;
      }
 
    const
    std::string & message() const
      {
          return M_message;
      }
 
};
 
 
class PlayerPointtoCommand
    : public PlayerSupportCommand {
private:
    bool M_on; 
    double M_dist; 
    double M_dir; 
public:
    PlayerPointtoCommand()
        : M_on( false )
        , M_dist( 0.0 )
        , M_dir( 0.0 )
      { }
 
    PlayerPointtoCommand( const double & dist,
                          const double & rel_dir )
        : M_on( true )
        , M_dist( dist )
        , M_dir( rel_dir )
      { }
 
    Type type() const
      {
          return POINTTO;
      }
 
    std::ostream & toCommandString( std::ostream & to ) const;
 
    std::string name() const
      {
          return std::string( "pointto" );
      }
 
 
    bool pointtoOn() const
      {
          return M_on;
      }
 
    const
    double & pointtoDist() const
      {
          return M_dist;
      }
 
    const
    double & pointtoDir() const
      {
          return M_dist;
      }
};
 
 
class PlayerAttentiontoCommand
    : public PlayerSupportCommand {
public:
    enum SideType {
        OUR,
        OPP,
        NONE,
    };
 
private:
    SideType M_side; 
    int M_number; 
public:
    PlayerAttentiontoCommand()
        : M_side( NONE )
        , M_number( 0 )
      { }
 
    PlayerAttentiontoCommand( const SideType side,
                              const int unum )
        : M_side( side )
        , M_number( unum )
      { }
 
    Type type() const
      {
          return ATTENTIONTO;
      }
 
    std::ostream & toCommandString( std::ostream & to ) const;
 
    std::string name() const
      {
          return std::string( "attentionto" );
      }
 
    bool isOn() const
      {
          return M_side != NONE;
      }
 
    SideType side() const
      {
          return M_side;
      }
 
    int number() const
      {
          return M_number;
      }
};
 
 
class PlayerCLangCommand
    : public PlayerSupportCommand {
private:
    int M_min; 
    int M_max; 
public:
    PlayerCLangCommand( const int min_version,
                        const int max_version )
        : M_min( min_version )
        , M_max( max_version )
      { }
 
    Type type() const
      {
          return CLANG;
      }
 
    std::ostream & toCommandString( std::ostream & to ) const;
 
    std::string name() const
      {
          return std::string( "clang" );
      }
 
    int minVer() const
      {
          return M_min;
      }
 
    int maxVer() const
      {
          return M_max;
      }
};
 
 
class PlayerEarCommand
    : public PlayerSupportCommand {
public:
    enum OnOffType {
        ON,
        OFF,
    };
    enum SideType {
        OUR,
        OPP,
    };
    enum ModeType {
        COMPLETE,
        PARTIAL,
        ALL,
    };
 
private:
    OnOffType M_onoff; 
    SideType M_side; 
    ModeType M_mode; 
public:
    PlayerEarCommand( const OnOffType onoff,
                      const SideType side )
        : M_onoff( onoff )
        , M_side( side )
        , M_mode( ALL )
      { }
 
    PlayerEarCommand( const OnOffType onoff,
                      const SideType side,
                      const ModeType mode )
        : M_onoff( onoff )
        , M_side( side )
        , M_mode( mode )
      { }
 
    Type type() const
      {
          return EAR;
      }
 
    std::ostream & toCommandString( std::ostream & to ) const;
 
    std::string name() const
      {
          return std::string( "ear" );
      }
 
 
    OnOffType onOff() const
      {
          return M_onoff;
      }
 
    SideType side() const
      {
          return M_side;
      }
 
    ModeType mode() const
      {
          return M_mode;
      }
 
};
 
 
class PlayerSenseBodyCommand
    : public PlayerSupportCommand {
private:
 
public:
    PlayerSenseBodyCommand()
      { }
 
    Type type() const
      {
          return SENSE_BODY;
      }
 
    std::ostream & toCommandString( std::ostream & to ) const;
 
    std::string name() const
      {
          return std::string( "sense_body" );
      }
};
 
 
class PlayerScoreCommand
    : public PlayerSupportCommand {
private:
 
public:
    PlayerScoreCommand()
      { }
 
    Type type() const
      {
          return SCORE;
      }
 
    std::ostream & toCommandString( std::ostream & to ) const;
 
    std::string name() const
      {
          return std::string( "score" );
      }
};
 
 
class PlayerCompressionCommand
    : public PlayerSupportCommand {
private:
    int M_level; 
public:
    explicit
    PlayerCompressionCommand( const int level )
        : M_level( level )
      { }
 
    Type type() const
      {
          return COMPRESSION;
      }
 
    std::ostream & toCommandString( std::ostream & to ) const;
 
    std::string name() const
      {
          return std::string( "compression" );
      }
 
    int level() const
      {
          return M_level;
      }
};
 
 
 
class PlayerDoneCommand
    : public PlayerSupportCommand {
private:
 
public:
    PlayerDoneCommand()
      { }
 
    Type type() const
      {
          return DONE;
      }
 
    std::ostream & toCommandString( std::ostream & to ) const;
 
    std::string name() const
      {
          return std::string( "done" );
      }
};
 
}
 
/*
 
init,
"(init <teamname>)"
"(init <teamname> (version <ver>))"
"(init <teamname> (version <ver>) (goalie))"
 
bye,
"(bye)"
 
 
 
move,
"(move <x> <y>)"
"(move (<x> <y>))"
 
dash,
"(dash <power>)"
 
turn,
"(turn <moment>)"
 
kick,
"(kick <power> <dir>)"
 
catch,
"(catch <dir>)"
 
tackle,
"(tackle <power>)"
 
 
 
turn_neck,
"(turn_neck <moment>)"
 
change_view,
"(change_view <width> <qual>)"
<width> :- narrow | normal | wide
<qual> :- high | low
 
say,
"(say <message>)"
"(say "<message>")" <--- in server 8+, to use the double quatation is recommended
 
pointto,
"(pointto <dist> <dir>)"
"(pointto off)"
 
attentionto,
"(attentionto <side> <number>)"
"(attentionto off)"
side :- our | opp | l | left | r | right | TEAMNAME
<--- server check the string in this order
 
clang,
"(clang (ver <min> <max>))"
 
ear,
"(ear <flag> <side> <mode>)"
"(ear <flag> <mode>)"
"(ear <flag> <side>)"
"(ear <flag>)"
<flag> :- on | off
<side> :- our | opp | left | l | right | r | TEAMNAME
<mode> :- partial | p | complete | c
 
 
sense_body,
"(sense_body)"
 
score,
"(score)"
 
compression,
"(compression <level>)"
<level> :- [0-9]
 
done,
"(done)"
 
 
 
*/
 
#endif