soccertypes.h

机器足球2D比赛程序 对trlen_base_2002的改进

  REFC_PENALTY_READY_RIGHT,    /*!< penalty_ready_right ready for pen. r team */
  REFC_PENALTY_TAKEN_LEFT,     /*!< penalty_ready_left  pen. taken by  l team */
  REFC_PENALTY_TAKEN_RIGHT,    /*!< penalty_ready_right pen. taken by  r team */
  REFC_PENALTY_MISS_LEFT,      /*!< penalty_miss_left   penalty missed r team */
  REFC_PENALTY_MISS_RIGHT,     /*!< penalty_miss_right  penalty missed l team */
  REFC_PENALTY_SCORE_LEFT,     /*!< penalty_score_left  penalty score l team  */
  REFC_PENALTY_SCORE_RIGHT,    /*!< penalty_score_right penalty score r team  */
  REFC_PENALTY_FOUL_LEFT,      /*!< penalty_foul_left   penalty foul l team   */
  REFC_PENALTY_FOUL_RIGHT,     /*!< penalty_foul_right  penalty foul r team   */
  REFC_PENALTY_ONFIELD_LEFT,   /*!< penalty_onfield_left pen. on left field   */
  REFC_PENALTY_ONFIELD_RIGHT,  /*!< penalty_onfield_right pen. on right field */
  REFC_PENALTY_WINNER_LEFT,    /*!< penalty_winner_l    penalty won by r team */
  REFC_PENALTY_WINNER_RIGHT,   /*!< penalty_winner_r    penalty won by l team */
  REFC_PENALTY_DRAW            /*!< penalty_draw        penalty result = draw */
} ;

/*! 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_TACKLE,       /*!< tackle in current body direction   */
  CMD_POINTTO,      /*!< point arm towards a point on field */
  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,    /*!< sweeper 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    */
  MAX_PLAYER_TYPES
} ;

/*! The PlayerSetT enumeration contains different sets of playertypes that
    are defined in a formation. Possible sets are all midfielders, etc. */
enum PlayerSetT {
  PS_DEFENDERS,           /*!< all defenders       */
  PS_MIDFIELDERS,         /*!< all midfielders     */
  PS_ATTACKERS,           /*!< all attackers       */
  PS_ALL                  /*!< all players         */
} ;

/*!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_334_OFFENSIVE,       /*!< 434 offensive formation                 */
  FT_DEFENSIVE,           /*!< defensive formation type                */
  FT_OPEN_DEFENSIVE,      /*!< open defensive formation type           */
  FT_343_ATTACKING,       /*!< attacking formation type                */
  MAX_FORMATION_TYPES
} ;

/*!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) */
  ACT_TACKLE,                     /*!< tackle the ball                       */
  ACT_HOLD_BALL                   /*!< hold the ball                         */
} ;

/*! The CoordActionT enumeration contains the considered actions in the 
   coordination algorithm. */
enum CoordActionT {
  COORDACT_ILLEGAL,               /*!< illegal dribble                       */
  COORDACT_MOVE_NORTH,            /*!< move north                            */
  COORDACT_MOVE_EAST,             /*!< move east                             */
  COORDACT_MOVE_SOUTH,            /*!< move south                            */
  COORDACT_MOVE_WEST,             /*!< move west                             */
  COORDACT_HOLD,                  /*!< hold position                         */
  COORDACT_GOTO_STRAT_POS,        /*!< go to strategic position              */
  COORDACT_PASS,                  /*!< pass                                  */
  COORDACT_DRIBBLE,               /*!< dribble                               */
  COORDACT_MAX                    /*!< number of actions                     */
} ;

/*! The RoleT enumeration contains the different roles a player can attain.  */
enum RoleT { 
  ROLE_PASSER,                    /*!< passer, player with the ball          */
  ROLE_RECEIVER,                  /*!< possible receiver of a pass           */
  ROLE_MAX                        /*!< number of roles                       */
} ;

/*! 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   */
} ;

/*! The TiredNessT enumeration contains different values that indicate how
    tired an agent is. */
enum TiredNessT {
  TIREDNESS_ILLEGAL,     /*!< illegal tiredness value                       */
  TIREDNESS_GOOD,        /*!< player is not tired at all                    */
  TIREDNESS_AVERAGE,     /*!< average tiredness                             */
  TIREDNESS_BAD,         /*!< player starts to get tired                    */
  TIREDNESS_VERY_BAD,    /*!< player is so tired it can hardly move         */
  TIREDNESS_TERRIBLE     /*!< player is so tired it cannot move             */ 
} ;

/*! The FeaturesT enumeration contains different features that can be saved.
    In this case, features represent specific information concerning the 
    current state. When specific information is calculated once (e.g., the 
    fastest opponent to the ball). This information can be stored. In the 
    next request for this information, the stored result is immediately 
    returned. */
enum FeatureT {
  FEATURE_ILLEGAL,                   /*!< illegal feature                    */
  FEATURE_FASTEST_OPPONENT_TO_BALL,  /*!< fastest opponent to the ball       */
  FEATURE_FASTEST_TEAMMATE_TO_BALL,  /*!< fastest teammate to the ball       */
  FEATURE_FASTEST_PLAYER_TO_BALL,    /*!< fastest player to the ball         */
  FEATURE_FASTEST_TEAMMATE_TO_BALL_NO_GOALIE, /*!< fastest teammate, no goali*/
  FEATURE_INTERCEPTION_POINT_BALL,   /*!< interception point ball            */
  FEATURE_INTERCEPT_CLOSE,           /*!< close interception point ball      */
  FEATURE_INTERCEPT_CYCLES_ME,       /*!< nr of cycles for me to intercept   */
  FEATURE_BEST_SCORING_POINT,        /*!< best scoring point in the goal     */
  MAX_FEATURES
} ;
  
/*! The CoachMsgT enumeration contains the different types of (freeform)
    messages that can be received from the coach.  */
enum CoachMsgT {
  COACH_MSG_ILLEGAL,                 /*!< illegal message                    */
  COACH_MSG_OPP_PLAYER_TYPE          /*!< opponent player type assignment    */
} ;

/////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////
//                                                                                     //
//                                orit                                                 //
//                                                                                     //
/////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////

/*! The POST enumeration contains different values that indicate the 
    object's positon to me */
enum Pos2MeT {
  POS_ILLEGAL,            /*!< illegal position value                       */
  POS_FRONT,              /*!< in front of me                               */
  POS_BEHIND,             /*!< at the behind of me                          */
  POS_SAME_FIELD,         /*!< stay with me in the same field               */
  POS_DIFFERENT_FIELD,     /*!< stay with me in the different field          */
  POS_AREA456             //位于四、五、六区
} ;

/*! 行为模式类型 
 */
enum ActionModeT {
	AMT_ILLEGAL,          //非法模式
	AMT_LOCATION,         //定位模式
	AMT_SEARCHBALL,       //找球模式
	AMT_HANDLEBALL,       //控球模式
	AMT_ACTOFF,           //积极进攻模式
	AMT_AUXOFF,           //辅助进攻模式
	AMT_PASOFF,           //被动进攻模式
	AMT_ACTDEF,           //积极防守模式
	AMT_AUXDEF,           //辅助防守模式
	AMT_PASDEF            //被动防守模式
};

/*! through_pass类型
 */
enum ThroughPassT {
	TPT_ILLEGAL,
    TPT_SIDE,             //传给边路
	TPT_MID,              //传给中路
	TPT_AREA1,            //传给一区的队友
	TPT_AREA2,            //传给二区的队友