coach_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_COACH_COMMAND_H
#define RCSC_COACH_COMMAND_H
 
#include <rcsc/types.h>
 
#include <string>
#include <vector>
#include <utility>
#include <iostream>
 
namespace rcsc {
 
class CoachCommand {
public:
    enum Type {
        INIT,
        BYE,
 
        CHECK_BALL,
        LOOK,
        TEAM_NAMES,
 
        EYE,
 
        CHANGE_PLAYER_TYPE,
        CHANGE_PLAYER_TYPES,
 
        CLANG_FREEFORM,
 
        TEAM_GRAPHIC,
        COMPRESSION,
        DONE,
 
        ILLEGAL
    };
 
    /*
    enum CLangType {
    CLANG_META,
    CLANG_FREEFORM,
    CLANG_INFO,
    CLANG_ADVICE,
    CLANG_DEFINE,
        CLANG_ADVISE,
        CLANG_ILLEGAL
    };
    */
 
protected:
    CoachCommand()
      { }
 
public:
    virtual
    ~CoachCommand()
      { }
 
    virtual
    Type type() const = 0;
 
    virtual
    std::ostream & toCommandString( std::ostream & to ) const = 0;
 
    virtual
    std::string name() const = 0;
};
 
 
 
class CoachInitCommand
    : public CoachCommand {
private:
    std::string M_team_name; 
    double M_version; 
    std::string M_coach_name; 
public:
    CoachInitCommand( const std::string & team_name,
                      const double & version,
                      const std::string & coach_name = "" );
 
    Type type() const
      {
          return INIT;
      }
 
    std::ostream & toCommandString( std::ostream & to ) const;
 
    std::string name() const
      {
          return std::string( "init" );
      }
};
 
 
class CoachByeCommand
    : public CoachCommand {
private:
 
public:
    CoachByeCommand()
      { }
 
    Type type() const
      {
          return BYE;
      }
 
    std::ostream & toCommandString( std::ostream & to ) const;
 
    std::string name() const
      {
          return std::string( "bye" );
      }
};
 
 
class CoachCheckBallCommand
    : public CoachCommand {
private:
 
public:
    CoachCheckBallCommand()
      { }
 
    Type type() const
      {
          return CHECK_BALL;
      }
 
    std::ostream & toCommandString( std::ostream & to ) const;
 
    std::string name() const
      {
          return std::string( "check_ball" );
      }
};
 
 
class CoachLookCommand
    : public CoachCommand {
private:
 
public:
    CoachLookCommand()
      { }
 
    Type type() const
      {
          return LOOK;
      }
 
    std::ostream & toCommandString( std::ostream & to ) const;
 
    std::string name() const
      {
          return std::string( "look" );
      }
};
 
 
class CoachTeamNamesCommand
    : public CoachCommand {
private:
 
public:
    CoachTeamNamesCommand()
      { }
 
    Type type() const
      {
          return TEAM_NAMES;
      }
 
    std::ostream & toCommandString( std::ostream & to ) const;
 
    std::string name() const
      {
          return std::string( "team_names" );
      }
};
 
 
class CoachEyeCommand
    : public CoachCommand {
private:
    bool M_on; 
public:
    explicit
    CoachEyeCommand( bool on )
        : M_on( on )
      { }
 
    Type type() const
      {
          return EYE;
      }
 
    std::ostream & toCommandString( std::ostream & to ) const;
 
    std::string name() const
      {
          return std::string( "eye" );
      }
};
 
 
class CoachChangePlayerTypeCommand
    : public CoachCommand {
private:
    int M_unum; 
    int M_type; 
public:
    CoachChangePlayerTypeCommand( const int unum,
                                  const int type )
        : M_unum( unum )
        , M_type( type )
      { }
 
    Type type() const
      {
          return CHANGE_PLAYER_TYPE;
      }
 
    std::ostream & toCommandString( std::ostream & to ) const;
 
    std::string name() const
      {
          return std::string( "change_player_type" );
      }
};
 
 
 
class CoachChangePlayerTypesCommand
    : public CoachCommand {
private:
    std::vector< std::pair< int, int > > M_types;
 
public:
    CoachChangePlayerTypesCommand( const int unum,
                                   const int type );
 
    CoachChangePlayerTypesCommand( const std::vector< std::pair< int, int > >  & types );
 
    void add( const int unum,
              const int type );
 
    Type type() const
      {
          return CHANGE_PLAYER_TYPES;
      }
 
    std::ostream & toCommandString( std::ostream & to ) const;
 
    std::string name() const
      {
          return std::string( "change_player_types" );
      }
};
 
 
class CoachFreeformCommand
    : public CoachCommand {
private:
    const double M_version;
    const std::string & M_message;
 
    // not used
    CoachFreeformCommand() = delete;
    CoachFreeformCommand( const CoachCommand & ) = delete;
    CoachFreeformCommand & operator=( const CoachCommand & ) = delete;
public:
    CoachFreeformCommand( const double & version,
                          const std::string & message )
        : CoachCommand(),
          M_version( version ),
          M_message( message )
      { }
 
    Type type() const
      {
          return CLANG_FREEFORM;
      }
 
    std::ostream & toCommandString( std::ostream & to ) const;
 
    std::string name() const
      {
          return std::string( "freeform" );
      }
};
 
 
class CoachTeamGraphicCommand
    : public CoachCommand {
private:
    unsigned int M_x; 
    unsigned int M_y; 
    std::vector< std::string > M_xpm_lines; 
 
public:
    CoachTeamGraphicCommand( const unsigned int x,
                             const unsigned int y,
                             const std::vector< std::string > & xpm_lines );
 
    Type type() const
      {
          return TEAM_GRAPHIC;
      }
 
    std::ostream & toCommandString( std::ostream & to ) const;
 
    std::string name() const
      {
          return std::string( "team_graphic" );
      }
};
 
 
 
class CoachCompressionCommand
    : public CoachCommand {
private:
    int M_level; 
public:
    explicit
    CoachCompressionCommand( 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" );
      }
};
 
 
 
class CoachDoneCommand
    : public CoachCommand {
private:
 
public:
    CoachDoneCommand()
      { }
 
    Type type() const
      {
          return DONE;
      }
 
    std::ostream & toCommandString( std::ostream & to ) const;
 
    std::string name() const
      {
          return std::string( "done" );
      }
};
 
}
 
/*
 
Online Coach Initialization Command
  See rcssserver/src/netif.C : void Stadium::parseOnlineCoachInit
      rcssserver/src/field.C : OnlineCoach* Stadium::newCoach
 
if illegal command
  -> "(error illegal_command_form)"
----------
  Coach's default version is 5.0
 
"(init TEAM_NAME (version VERSION))"
  if TEAM_NAME and VERSION is illegal
    -> "(error no_such_team_or_already_have_coach)"
  else
    if VERSION >= 6.0
      -> "(init l ok)" or "(init r ok)"
    else
      -> "(init ok)"
 
  receive parameter info
  receive changed players info
  receive each player's clang version
 
    if VERSION >= 7.0
      -> "(server_param ...)" "(player_param ...)" "(player_type ...)"x7
      -> "(change_player_type UNUM ID)" "(change_player_type UNUM)" "(change_player_type TEAM_NAME UNUM ID)"
    if VERSION >= 8.0
      -> "(clang (ver PLAYER_SHORT_NAME MIN MAX))"
----------
 
----------
 
----------
Online Coach Command List
  See rcssserver/src/netif.C : void Coach::parse_command(const char *command)l
 
if use illegal character for command string
  -> "(error illegal_command_form)"
else if illegal command
  -> "(error unknown_command)"
 
----------
"(check_ball)" : check ball positional state
  -> (ok check_ball BALL_POS_INFO)
  BALL_POS_INFO :- "in_field" | "goal_l" | "goal_r" | "out_of_field"
----------
"(look)" : get all movable objects' positional information
  -> "(ok look TIME GOAL_INFO BALL_INFO PLAYER_INFO ...)"
----------
"(team_names)" : get team name
  -> "(ok team_names (team l TEAM_NAME) (team r TEAM_NAME))"
----------
"(say MESSAGE)" : say advice message (if version > 7.0, it must be CLang.)
  if version >= 7.0
  {
    if MESSAGE cannot be parsed
      -> "(error could_not_parse_say)"
    else
    {
      if MESSAGE is MetaType
        if MetaType has no left
          -> "(error said_too_many_meta_messages)"
        else
          -> "(ok say)"
      else if MESSAGE is FreeFormType
        if FreeFormType is enable now
          if FreeFormType has no left
            -> "(error said_too_many_freeform_messages)"
          else
            -> "(ok say)"
        else
          -> "(error cannot_say_freeform_while_playon)"
      else if MESSAGE is InfoType
        if InfoType has no left
          -> "(error said_too_many_info_messages)"
        else
          -> "(ok say)"
      else if MESSAGE is AdviceType
        if AdviceType has no left
          -> "(error said_too_many_advice_messages)"
        else
          -> "(ok say)"
      else if MESSAGE is DefineType
        if DefineType has no left
          -> "(error said_too_many_define_messages)"
        else
          -> "(ok say)"
      else if MESSAGE is DeleteType
        if DeleteType has no left
          -> "(error said_too_many_del_messages)"
        else
          -> "(ok say)"
      else if MESSAGE is RuleType
        if RuleType has no left
          -> "(error said_too_many_rule_messages)"
        else
          -> "(ok say)"
    }
  }
  else // version < 7.0, CLang is not supported
  {
    if playmode is PlayOn
      -> "(warning cannot_say_while_playon)"
    else if coach's say has no left
      -> "(error said_too_many_messages)"
    else
      if MESSAGE uses illegal charcter or is NULL string
        -> "(error illegal_command_form)"
      else
        -> "(ok say)"
  }
----------
"(bye)" : close connection
----------
"(eye ONOFF)" : turn on/off to get visual info
  if ONOFF is NULL
    -> "(error illegal_command_form)"
  else if ONOFF_MODE == "on"
    -> "(ok eye on)"
  else if ONOFF_MODE == "off"
    -> "(ok eye off)"
  else
    -> "(error illegal_command_form)"
----------
"(change_player_type UNUM PLAYER_TYPE_ID)" : change hetero player type
  if playmode is PlayOn
    -> "(warning cannot_sub_while_playon)"
  else if coach's side is Unknown
    -> "(warning no_team_found)"
  else if team_subs_count == subsMax
    -> "(warning no_subs_left)"
  else if UNUM or PLAYER_TYPE_ID has illegal form (eg. NULL string)
    -> "(error illegal_command_form)"
  else if PLAYER_TYPE_ID is out of range (ID<0 or PlayerTypes<ID)
    -> "(error out_of_range_player_type)"
  else if UNUM is not match
    -> "(warning no_such_player)"
  else if player is goalie && PLAYER_TYPE_ID != 0
    -> "(warning cannot_change_goalie)"
  else if ID != 0 && ID's player count == ptMax() && player's id != ID
    -> "(warning max_of_that_type_on_field)"
  else
    -> "(ok change_player_type UNUM PLAYER_TYPE_ID)\n
----------
"(done)" : thinking end nortification for sync mode
----------
"(compression LEVEL)" : set zlib compression level
  if LEVEL is NULL string
    -> "(error illegal_command_form)"
  else if not HAVE_LIBZ
    -> "(warning compression_unsupported)"
  else if (LEVEL < 0 || 9 < LEVEL)
    -> "(error illegal_command_form)"
  else
    -> "(ok compression LEVEL)"
----------
"(team_graphic (X Y "XPMLINE" ... "XPMLINE"))" : change team graphic on rcssmonitor
  if playmode is not BeforeKickOff
    -> "warning only_before_kick_off"
  else if X or Y is illegal (eg. NULL string)
    -> "(error illegal_command_form)"
  else if (X >= 32 || Y = 8)
    -> "(warning invalid_tile_location)"
  else if (xpm's width != 8 || xpm's height != 8)
    -> "(warning invalid_tile_size)"
  else
    -> "(ok team_graphic X Y)"
----------
*/
 
 
#endif