soccertypes.h

trilearn_2002_source_tar.gz , University of Amsterdam的2002年robocup源程序代码

  OBJECT_SET_PLAYERS,    /*!< players   */
  OBJECT_SET_FLAGS,      /*!< flags     */
  OBJECT_SET_LINES,      /*!< lines     */
  OBJECT_SET_ILLEGAL     /*!< illegal   */
} ;

/*!The PlayModeT enumeration contains all playmodes of the soccer playmode.
   The associated string values can be returned using the methods in the
   SoccerTypes class */
enum PlayModeT {
  PM_BEFORE_KICK_OFF,        /*!< before_kick_off:   before kick off          */
  PM_KICK_OFF_LEFT,          /*!< kick_off_l:        kick off for left team   */
  PM_KICK_OFF_RIGHT,         /*!< kick_off_r:        kick off for right team  */
  PM_KICK_IN_LEFT,           /*!< kick_in_l:         kick in for left team    */
  PM_KICK_IN_RIGHT,          /*!< kick_in_r:         kick in for right team   */
  PM_CORNER_KICK_LEFT,       /*!< corner_kick_l:     corner kick left team    */
  PM_CORNER_KICK_RIGHT,      /*!< corner_kick_r:     corner kick right team   */
  PM_GOAL_KICK_LEFT,         /*!< goal_kick_l:       goal kick for left team  */
  PM_GOAL_KICK_RIGHT,        /*!< goal_kick_r:       goal kick for right team */
  PM_GOAL_LEFT,              /*!< goal_l:            goal scored by team left */
  PM_GOAL_RIGHT,             /*!< goal_r:            goal scored by team right*/
  PM_FREE_KICK_FAULT_LEFT,   /*!< free_kick_fault_l: free_kick to yourself    */
  PM_FREE_KICK_FAULT_RIGHT,   /*!< free_kick_fault_r: free_kick to yourself    */
  PM_FREE_KICK_LEFT,         /*!< free_kick_l:       free kick for left team  */
  PM_FREE_KICK_RIGHT,        /*!< free_kick_r:       free kick for right team */
  PM_BACK_PASS_LEFT,         /*!< back_pass_l:       left team passed back    */
  PM_BACK_PASS_RIGHT,        /*!< back_pass_r:       right team passed back   */
  PM_OFFSIDE_LEFT,           /*!< offside_l:         offside for left team    */
  PM_OFFSIDE_RIGHT,          /*!< offside_r:         offside for right team   */
  PM_PLAY_ON,                /*!< play_on:           play on (during match)   */
  PM_TIME_OVER,              /*!< time_over:         time over (after match)  */
  PM_FROZEN,                 /*!< game play is frozen                         */
  PM_QUIT,                   /*!< quit                                        */
  PM_ILLEGAL                 /*!< unknown playmode                            */
} ;                           

/*! The RefereeT enumeration contains all messages that the referee can sent.
    The SoccerTypes class contains different methods to convert these messages
    to the corresponding playmode. */
enum RefereeMessageT {
  REFC_ILLEGAL,                /*!< unknown message                           */
  REFC_BEFORE_KICK_OFF,        /*!< before_kick_off:   before kick off        */
  REFC_KICK_OFF_LEFT,          /*!< kick_off_l:        kick off for left team */
  REFC_KICK_OFF_RIGHT,         /*!< kick_off_r:        kick off for right team*/
  REFC_KICK_IN_LEFT,           /*!< kick_in_l:         kick in for left team  */
  REFC_KICK_IN_RIGHT,          /*!< kick_in_r:         kick in for right team */
  REFC_CORNER_KICK_LEFT,       /*!< corner_kick_l:     corner kick left team  */
  REFC_CORNER_KICK_RIGHT,      /*!< corner_kick_r:     corner kick right team */
  REFC_GOAL_KICK_LEFT,         /*!< goal_kick_l:       goal kick left team    */
  REFC_GOAL_KICK_RIGHT,        /*!< goal_kick_r:       goal kick right team   */
  REFC_FREE_KICK_LEFT,         /*!< free_kick_l:       free kick left team    */
  REFC_FREE_KICK_RIGHT,        /*!< free_kick_r:       free kick right team   */
  REFC_FREE_KICK_FAULT_LEFT,   /*!< free_kick_fault_l: free_kick to yourself  */
  REFC_FREE_KICK_FAULT_RIGHT,   /*!< free_kick_fault_r: free_kick to yourself  */
  REFC_BACK_PASS_LEFT,         /*!< back_pass_l:       left team passed back  */
  REFC_BACK_PASS_RIGHT,        /*!< back_pass_r:       right team passed back */
  REFC_PLAY_ON,                /*!< play_on:           play on (during match) */
  REFC_TIME_OVER,              /*!< time_over:         time over (after match)*/
  REFC_FROZEN,                 /*!< frozen:            game play is frozen    */
  REFC_QUIT,                   /*!< quit:              quit                   */
  REFC_OFFSIDE_LEFT,           /*!< offside_l          offside left           */
  REFC_OFFSIDE_RIGHT,          /*!< offside_r          offside right          */
  REFC_HALF_TIME,              /*!< half_time:         it is half time        */
  REFC_TIME_UP,                /*!< time_up:           match has finished     */
  REFC_TIME_UP_WITHOUT_A_TEAM, /*!< time_up_without_a_team: match finished    */
  REFC_TIME_EXTENDED,          /*!< time_extended:     time continues-overtime*/
  REFC_FOUL_LEFT,              /*!< foul_l:            foul made by left      */
  REFC_FOUL_RIGHT,             /*!< foul_r:            foul made by right     */
  REFC_GOAL_LEFT,              /*!< goal_l:            goal made by left      */
  REFC_GOAL_RIGHT,             /*!< goal_r:            goal made by right     */
  REFC_DROP_BALL,              /*!< drop_ball:         ball is dropped        */
  REFC_GOALIE_CATCH_BALL_LEFT, /*!< goalie_catch_ball_l: left goalie catch    */
  REFC_GOALIE_CATCH_BALL_RIGHT /*!< goalie_catch_ball_r: right goalie catch   */
} ;

/*! The ViewAngleT enumeration contains the different view angles that are
    possible for a player */
enum ViewAngleT  {
  VA_NARROW,  /*!< view angle narrow  */
  VA_NORMAL,  /*!< view angle normal  */
  VA_WIDE,    /*!< view angle wide    */
  VA_ILLEGAL  /*!< illegal view angle */
};

/*!The ViewQualityT enumeration contains the different view qualities possible
   for a player. */
enum ViewQualityT {
  VQ_HIGH,    /*!< view quality high    */
  VQ_LOW,     /*!< view quality low     */
  VQ_ILLEGAL  /*!< illegal view quality */
};

/*!The SideT enumeration contains the two sides */
enum SideT {
  SIDE_LEFT,     /*!< left side    */
  SIDE_RIGHT,    /*!< right SIDE   */
  SIDE_ILLEGAL   /*!< illegal SIDE */
} ;

/*!The CommandT enumeration contains the different types for the SoccerCommand
   that are possible. */
enum CommandT {
  CMD_ILLEGAL,      /*!< illegal command */
  CMD_DASH,         /*!< dash command (player only)         */
  CMD_TURN,         /*!< turn command (player only)         */
  CMD_TURNNECK,     /*!< turn_neck command (player only)    */
  CMD_CHANGEVIEW,   /*!< change view command (player only)  */
  CMD_CATCH,        /*!< catch command (goalie only)        */
  CMD_KICK,         /*!< kick command (player only)         */
  CMD_MOVE,         /*!< move command                       */
  CMD_SENSEBODY,    /*!< sense_body command (player only)   */
  CMD_SAY,          /*!< say command                        */
  CMD_CHANGEPLAYER, /*!< change_player command (coach only) */
  CMD_ATTENTIONTO,  /*!< pay attention to specific player   */
  CMD_MAX_COMMANDS  /*!< maximum number of commands         */
} ;

/*!The PlayerT enumeration contains the different playertypes that are defined
   in a formation. This should not be confused with the later introducted
   player_types in soccerserver 7.xx that denotes the different possible
   heterogeneous players. A player type in the context PlayerT denotes the
   kind of player (midfielder, attacker) on the field. Its role on the pitch.*/
enum PlayerT {
  PT_ILLEGAL,             /*!< illegal player type */
  PT_GOALKEEPER,          /*!< goalkeeper          */
  PT_DEFENDER_SWEEPER,    /*!< central defender    */
  PT_DEFENDER_WING,       /*!< wing defender       */
  PT_MIDFIELDER_CENTER,   /*!< central midfielder  */
  PT_MIDFIELDER_WING,     /*!< wing midfielder     */
  PT_ATTACKER_WING,       /*!< wing attacker       */
  PT_ATTACKER             /*!< central attacker    */
} ;

/*!The FormationT enumeration contains the different formation types that
   are defined. */
enum FormationT {
  FT_ILLEGAL,             /*!< illegal formation type                  */
  FT_INITIAL,             /*!< initial formation type (before kick off)*/
  FT_433_OFFENSIVE,       /*!< 433 offensive formation                 */
  FT_433_DEFENSIVE,       /*!< 433 offensive formation                 */  
  FT_DEFENSIVE,           /*!< defensive formation type                */
  FT_OPEN_DEFENSIVE,      /*!< open defensive formation type           */
  FT_ATTACKING            /*!< attacking formation type                */
} ;

/*!The BallStatus enumeration contains the status of the ball. This is returned
   when the coach has issued the check_ball message. */
enum BallStatusT {
  BS_ILLEGAL,           /*!< illegal ball status      */
  BS_IN_FIELD,          /*!< ball is in the field     */
  BS_GOAL_LEFT,         /*!< ball is in left goal     */
  BS_GOAL_RIGHT,        /*!< ball is in right goal    */
  BS_OUT_OF_FIELD       /*!< ball is not in the field */
} ;

/*!The ActionT enumeration contains different (high-level) actions. */
enum ActionT {
  ACT_ILLEGAL,                    /*!< illegal action (default)               */
  ACT_SEARCH_BALL,                /*!< search for the ball                    */
  ACT_KICK_BALL,                  /*!< kick the ball                          */
  ACT_CATCH_BALL,                 /*!< catch the ball                         */  
  ACT_INTERCEPT,                  /*!< intercept the ball                     */
  ACT_MARK,                       /*!< mark an opponent                       */
  ACT_TELEPORT_TO_STRATEGIC_POSITION, /*!< move to a strategic position (move)*/
  ACT_WATCH_BALL,                 /*!< watch the ball                         */
  ACT_ANTICIPATE_BALL,            /*!< turn in anticipation for ball          */
  ACT_GOTO_STRATEGIC_POSITION,    /*!< go to a strategic position (dash)      */
  ACT_TURN_BODY_TO_CENTER,        /*!< turn body to center of field           */
  ACT_MOVE_TO_DEAD_BALL_POSITION, /*!< move to pos in dead ball situation     */
  ACT_INTERCEPT_SCORING_ATTEMPT,  /*!< intercept ball heading to goal         */
  ACT_DEFEND_GOALLINE,            /*!< defend the goalline (for goalkeeper)   */
  ACT_TELEPORT_AFTER_CATCH        /*!< teleport after catch (for goalkeeper)  */
} ;

/*! The MarkT enumeration contains different marking techniques. */
enum MarkT {
  MARK_ILLEGAL,    /*!< illegal marking                                     */
  MARK_GOAL,       /*!< mark goal (stand on obj-goal line)                  */
  MARK_BISECTOR,   /*!< mark bisector stand between goal,obj and ball,obj   */
  MARK_BALL        /*!< mark ball (stand on obj-ball line)                  */
} ;

/*! The DribbleT enumeration contains different dribble possibilities. */
enum DribbleT {
  DRIBBLE_ILLEGAL, /*!< illegal dribbling                                   */
  DRIBBLE_WITHBALL,/*!< dribble with ball very close                        */
  DRIBBLE_SLOW,    /*!< dribble slowly but kicking ball slightly ahead      */
  DRIBBLE_FAST     /*!< dribble fast by kicking ball up front               */
} ;

/*! The PassT enumeration contains different passing possibilities. */
enum PassT {
  PASS_ILLEGAL,    /*!< illegal pass                                        */
  PASS_FAST,       /*!< pass fast to a teammate                             */
  PASS_NORMAL      /*!< pass normal to a teammate                           */
} ;

/*! The ClearBallT enumeration contains different clear ball possibilities. */
enum ClearBallT {
  CLEAR_BALL_ILLEGAL,    /*!< illegal clear ball                            */
  CLEAR_BALL_OFFENSIVE,  /*!< clear ball to the front of the field          */
  CLEAR_BALL_DEFENSIVE,  /*!< clear ball to the center line of the field    */
  CLEAR_BALL_OFFENSIVE_SIDE, /*!< clear ball to front and side of the field */
  CLEAR_BALL_GOAL        /*!< clear ball to position in front of the goal   */
} ;