memposition.h

RoboCup 2D 仿真组冠军源代码之1998年冠军队——CMUnited98源代码

/****************************************************************************************/
/****************************************************************************************/

class TempPlayerObject {
public:

  float    dist;  /* relative */
  AngleDeg ang;

  Time     time;
  char     side;

  inline void set(char s, float d, float a, Time t) { time = t; side = s; dist = d; ang = a; }
};




/****************************************************************************************/
/****************************************************************************************/
/****************************************************************************************/

#define MAX_MARKERS 100
#define MAX_PLAYERS 25

#define Unum_Unknown  0
#define Unum_Teamless 100

class PositionInfo : public PlayerInfo{
public:

  ~PositionInfo();
  void Initialize();

  void SeeLine  (SideLine l, float dist, float ang, Time tm);
  void SeeLine  (SideLine l, float ang, Time tm);

  void SeeMarker(MarkerType marker, float dist, float ang, Time tm);
  void SeeMarker(MarkerType marker, float ang, Time tm);
  void SeeMarker(MarkerType marker, float dist, float ang, float distChng, float dirChng, Time tm);

  void SeeBall(float ang, Time tm);
  void SeeBall(float dist, float ang, Time tm);
  void SeeBall(float dist, float ang, float distChng, float dirChng, Time tm);

  void SeePlayer(float ang, Time time);
  void SeePlayer(float dist, float ang, Time time);
  void SeePlayer(char side, float ang, Time time);
  void SeePlayer(char side, float dist, float ang, Time time);
  void SeePlayer(char side, Unum num, 
		 float dist, float ang, float distChng, float dirChng, float facedir, Time time);
  void SeePlayer(char side, Unum num, float dist, float ang, Time time);
  void SeePlayer(char side, Unum num, float ang, Time time);

  void HearBall(float x, float y, float conf, float dist, Time time);
  void HearBall(float x, float y, float pconf, float dx, float dy, float vconf, float dist, Time time);

  void HearPlayer(char side, Unum num, float x, float y, float conf, float dist, Time time);
  void HearPlayer(char side, Unum num,
		  float x, float y, float pconf, float dx, float dy, float vconf, float dist, Time time);
  void HearPlayer(char side, Unum num, float x, float y, float pconf, float dx, float dy, float vconf, 
		  AngleDeg face, float fconf, float dist, Time time);

  /* Access shortcuts -- Markers */
  inline float    MarkerDistance     (MarkerType m) { return GetMarker(m)->get_dist();  }
  inline AngleDeg MarkerAngle        (MarkerType m) { return GetMarker(m)->get_ang();   }
  inline Vector   MarkerPosition     (MarkerType m) { return GetMarker(m)->get_abs_pos();   }
  inline float    MarkerX            (MarkerType m) { return GetMarker(m)->get_x();     }
  inline float    MarkerY            (MarkerType m) { return GetMarker(m)->get_y();     }
  inline float    MarkerPositionValid(MarkerType m) { return GetMarker(m)->pos_valid(); }

  /* Access shortcuts -- Ball */
  inline float    BallDistance     () { return GetBall()->get_dist();  }
  inline AngleDeg BallAngle        () { return GetBall()->get_ang();   }
  inline Vector   BallAbsolutePosition() { return GetBall()->get_abs_pos();   }
  inline Vector   BallRelativePosition() { return GetBall()->get_rel_pos();   }
  inline float    BallX            () { return GetBall()->get_x();     }
  inline float    BallY            () { return GetBall()->get_y();     }
  inline float    BallPositionValid() { return GetBall()->pos_valid(); }

  inline float    BallSpeed          () { return GetBall()->get_speed();       }
  inline AngleDeg BallRelativeHeading() { return GetBall()->get_rel_heading(); }  
  inline AngleDeg BallAbsoluteHeading() { return GetBall()->get_abs_heading(); }  
  inline Vector   BallRelativeVelocity() { return GetBall()->get_rel_vel();    }  
  inline Vector   BallAbsoluteVelocity() { return GetBall()->get_abs_vel();    }  
  inline float    BallVelocityValid  () { return GetBall()->vel_valid();       }  
  inline Bool     BallMoving         () { return GetBall()->moving();          }
  inline Bool     BallKickable       (float buffer=0.0)
    { return GetBall()->kickable(buffer); }  
  inline Bool     BallCatchable      () 
    { return (GetBall()->catchable() && InOwnPenaltyArea() && 
	      CP_goalie && PlayMode == PM_Play_On)             ? TRUE : FALSE; }  
  inline float    BallKickRate       () { return GetBall()->get_kick_rate(CurrentTime);   }  

  /* Access shortcuts -- Players */
  inline float    PlayerDistance        (char s, Unum n) 
    { return (s==MySide && n==MyNumber) ? 0                         : GetPlayer(s,n)->get_dist();    }
  inline AngleDeg PlayerAngle           (char s, Unum n) 
    { return (s==MySide && n==MyNumber) ? 0                         : GetPlayer(s,n)->get_ang();     }
  inline Vector   PlayerAbsolutePosition(char s, Unum n) 
    { return (s==MySide && n==MyNumber) ? MyPos()                   : GetPlayer(s,n)->get_abs_pos(); }
  inline Vector   PlayerRelativePosition(char s, Unum n) 
    { return (s==MySide && n==MyNumber) ? Vector(0,0)               : GetPlayer(s,n)->get_rel_pos(); }
  inline float    PlayerX               (char s, Unum n) 
    { return (s==MySide && n==MyNumber) ? MyX()                     : GetPlayer(s,n)->get_x();       }
  inline float    PlayerY               (char s, Unum n) 
    { return (s==MySide && n==MyNumber) ? MyY()                     : GetPlayer(s,n)->get_y();       }
  float    PlayerPositionValid          (char s, Unum n);

  inline float    PlayerSpeed           (char s, Unum n) 
    { return (s==MySide && n==MyNumber) ? MySpeed()                 : GetPlayer(s,n)->get_speed();       }
  inline AngleDeg PlayerRelativeHeading (char s, Unum n) 
    { return (s==MySide && n==MyNumber) ? 0                         : GetPlayer(s,n)->get_rel_heading(); }  
  inline AngleDeg PlayerAbsoluteHeading (char s, Unum n) 
    { return (s==MySide && n==MyNumber) ? MyDir()                   : GetPlayer(s,n)->get_abs_heading(); }  
  inline Vector   PlayerAbsoluteVelocity(char s, Unum n) 
    { return (s==MySide && n==MyNumber) ? MyVel()                   : GetPlayer(s,n)->get_abs_vel();     }  
  inline Vector   PlayerRelativeVelocity(char s, Unum n) 
    { return (s==MySide && n==MyNumber) ? Polar2Vector(MySpeed(),0) : GetPlayer(s,n)->get_rel_vel();     }  
  float    PlayerVelocityValid          (char s, Unum n); 
  inline AngleDeg PlayerRelativeFace    (char s, Unum n) 
    { return (s==MySide && n==MyNumber) ? 0                         : GetPlayer(s,n)->get_rel_face();    }  
  inline AngleDeg PlayerAbsoluteFace    (char s, Unum n) 
    { return (s==MySide && n==MyNumber) ? MyAng()                   : GetPlayer(s,n)->get_abs_face();    }  
  float    PlayerFaceValid              (char s, Unum n);

  /* Access shortcuts -- Teammates */
  inline float    TeammateDistance        (Unum n) { return PlayerDistance        (MySide,n); }
  inline AngleDeg TeammateAngle           (Unum n) { return PlayerAngle           (MySide,n); }
  inline Vector   TeammateAbsolutePosition(Unum n) { return PlayerAbsolutePosition(MySide,n); }
  inline Vector   TeammateRelativePosition(Unum n) { return PlayerRelativePosition(MySide,n); }
  inline float    TeammateX               (Unum n) { return PlayerX               (MySide,n); }
  inline float    TeammateY               (Unum n) { return PlayerY               (MySide,n); }
  inline float    TeammatePositionValid   (Unum n) { return PlayerPositionValid   (MySide,n); }

  inline float    TeammateSpeed           (Unum n) { return PlayerSpeed           (MySide,n); }
  inline AngleDeg TeammateRelativeHeading (Unum n) { return PlayerRelativeHeading (MySide,n); }
  inline AngleDeg TeammateAbsoluteHeading (Unum n) { return PlayerAbsoluteHeading (MySide,n); }
  inline Vector   TeammateAbsoluteVelocity(Unum n) { return PlayerAbsoluteVelocity(MySide,n); }
  inline Vector   TeammateRelativeVelocity(Unum n) { return PlayerRelativeVelocity(MySide,n); }
  inline float    TeammateVelocityValid   (Unum n) { return PlayerVelocityValid   (MySide,n); }
  inline AngleDeg TeammateRelativeFace    (Unum n) { return PlayerRelativeFace    (MySide,n); }
  inline AngleDeg TeammateAbsoluteFace    (Unum n) { return PlayerAbsoluteFace    (MySide,n); }
  inline float    TeammateFaceValid       (Unum n) { return PlayerFaceValid       (MySide,n); }

  /* Access shortcuts -- Opponents */
  inline float    OpponentDistance        (Unum n) { return PlayerDistance        (TheirSide,n); }
  inline AngleDeg OpponentAngle           (Unum n) { return PlayerAngle           (TheirSide,n); }
  inline Vector   OpponentAbsolutePosition(Unum n) { return PlayerAbsolutePosition(TheirSide,n); }
  inline Vector   OpponentRelativePosition(Unum n) { return PlayerRelativePosition(TheirSide,n); }
  inline float    OpponentX               (Unum n) { return PlayerX               (TheirSide,n); }
  inline float    OpponentY               (Unum n) { return PlayerY               (TheirSide,n); }
  inline float    OpponentPositionValid   (Unum n) { return PlayerPositionValid   (TheirSide,n); }

  inline float    OpponentSpeed           (Unum n) { return PlayerSpeed           (TheirSide,n); }
  inline AngleDeg OpponentRelativeHeading (Unum n) { return PlayerRelativeHeading (TheirSide,n); }
  inline AngleDeg OpponentAbsoluteHeading (Unum n) { return PlayerAbsoluteHeading (TheirSide,n); }
  inline Vector   OpponentAbsoluteVelocity(Unum n) { return PlayerAbsoluteVelocity(TheirSide,n); }
  inline Vector   OpponentRelativeVelocity(Unum n) { return PlayerRelativeVelocity(TheirSide,n); }
  inline float    OpponentVelocityValid   (Unum n) { return PlayerVelocityValid   (TheirSide,n); }
  inline AngleDeg OpponentRelativeFace    (Unum n) { return PlayerRelativeFace    (TheirSide,n); }
  inline AngleDeg OpponentAbsoluteFace    (Unum n) { return PlayerAbsoluteFace    (TheirSide,n); }
  inline float    OpponentFaceValid       (Unum n) { return PlayerFaceValid       (TheirSide,n); }

  /* more complex shortcuts */
  /* kickable for other players */
  Bool BallKickableForPlayer(char s, Unum n, float buffer=0);
  inline Bool BallKickableForTeammate(Unum n, float buffer=0) 
    { return BallKickableForPlayer(MySide, n, buffer); }
  inline Bool BallKickableForOpponent(Unum n, float buffer=0) 
    { return BallKickableForPlayer(TheirSide, n, buffer); }

  /* is player behind us */
  /* three forms for third arg:
     angle: absolute angle indicating the front
     Vector: position whose direction indicates the front
     none: use MyAng */
  /* is point behind us */
  /* three forms for third arg:
     angle: absolute angle indicating the front
     Vector: position whose direction indicates the front
     none: use MyAng */
  inline Bool IsPointBehind(Vector pt, AngleDeg ang)
    {
      return (fabs(GetNormalizeAngleDeg(AngleTo(pt) + MyAng() - ang)) > CP_behind_angle)
	? TRUE : FALSE;      
    }
  inline Bool IsPointBehind(Vector pt, Vector targPos)
    {
      return IsPointBehind(pt, (targPos - MyPos()).dir());
    }
  inline Bool IsPointBehind(Vector pt)
    {
      return (fabs(AngleTo(pt)) > CP_behind_angle)
	? TRUE : FALSE;
    }

  inline Bool IsPlayerBehind(char s, Unum n, AngleDeg ang)
    {      
      if (!PlayerPositionValid(s, n))
	my_error("Can't tell if player is behind if I don't know where he is");
      return (fabs(PlayerAngle(s, n) + MyAng() - ang) > CP_behind_angle)
	? TRUE : FALSE;
    }
  inline Bool IsPlayerBehind(char s, Unum n, Vector targPos)
    {
      return IsPlayerBehind(s, n, (targPos - MyPos()).dir());
    }
  inline Bool IsPlayerBehind(char s, Unum n)
    {
      if (!PlayerPositionValid(s, n))
	my_error("Can't tell if player is behind if I don't know where he is");
      return (fabs(PlayerAngle(s, n)) > CP_behind_angle)
	? TRUE : FALSE;
    }

  inline Bool IsTeammateBehind(Unum n, AngleDeg ang)
    { return IsPlayerBehind(MySide, n, ang); }
  inline Bool IsTeammateBehind(Unum n, Vector targPos)
    { return IsPlayerBehind(MySide, n, targPos); }
  inline Bool IsTeammateBehind(Unum n)
    { return IsPlayerBehind(MySide, n); }
  
  inline Bool IsOpponentBehind(Unum n, AngleDeg ang)
    { return IsPlayerBehind(TheirSide, n, ang); }
  inline Bool IsOpponentBehind(Unum n, Vector targPos)
    { return IsPlayerBehind(TheirSide, n, targPos); }
  inline Bool IsOpponentBehind(Unum n)
    { return IsPlayerBehind(TheirSide, n); }
  
  
  /* Relative markers */
  MarkerType RM_My_Goal;
  MarkerType RM_Their_Goal;
  MarkerType RM_LB_Flag;
  MarkerType RM_LC_Flag;
  MarkerType RM_LF_Flag;
  MarkerType RM_RB_Flag;
  MarkerType RM_RC_Flag;
  MarkerType RM_RF_Flag;
  MarkerType RM_My_PC_Flag;    /* Center of my penalty area */
  MarkerType RM_Their_PC_Flag; /* Center of theirs          */

  /* predicted positions */
  Vector BallPredictedPosition(int steps, float kick_power, AngleDeg kick_dir);
  inline Vector BallPredictedPosition(int steps = 1) 
    { return GetBall()->estimate_future_pos(steps); }


  inline Vector PlayerPredictedPosition(char side, Unum num, int steps = 1, Vector dash_per=Vector(0,0))
    { return GetPlayer(side,num)->estimate_future_pos(steps, 0, dash_per); }
  inline Vector TeammatePredictedPosition(Unum num, int steps = 1, Vector dash_per=Vector(0,0)) 
    { return PlayerPredictedPosition(MySide,num,steps, dash_per); }
  inline Vector OpponentPredictedPosition(Unum num, int steps = 1, Vector dash_per=Vector(0,0)) 
    { return PlayerPredictedPosition(TheirSide,num,steps, dash_per); }

  Bool BallWillBeKickable(int steps = 1, float dash_power = 0, float buffer = 0);

  Bool WillKickBeCollision(float kick_power, AngleDeg kick_dir, float buffer = 0) 
    { return ((BallPredictedPosition(1, kick_power, kick_dir) - MyPredictedPosition()).mod() <= 
	      SP_player_size + SP_ball_size + buffer)  ? TRUE : FALSE;  } 
  Bool WillDashBeCollision(float dash_power, float buffer = 0) 
    { return ((BallPredictedPosition() - MyPredictedPosition(1, dash_power)).mod() <= 
          SP_player_size + SP_ball_size + buffer) ? TRUE : FALSE;  } 

  Unum PlayerWithBall(float buffer=0);    /* with ball means actually kickable      */
  Unum TeammateWithBall(float buffer=0);  
  Unum OpponentWithBall(float buffer=0);  
  char TeamWithBall(float buffer=0);   

  /* Direct access functions */
  inline StationaryObject *GetMarker(MarkerType m) { return &Marker[m]; }

  inline BallObject *GetBall() { return &Ball; }

  inline PlayerObject **Teammates() { return MyPlayer; }
  inline PlayerObject **Opponents() { return TheirPlayer; }
  inline PlayerObject **TeamlessPlayers() { return TeamlessPlayer; }

  inline int NumTeammates() { return num_my_players; }
  inline int NumOpponents() { return num_their_players; }
  inline int NumTeamlessPlayers()  { return num_teamless_players; }
  inline int NumPlayers()   { return num_my_players + num_their_players + num_teamless_players; }

  PlayerObject *GetTeammate(Unum num);
  PlayerObject *GetOpponent(Unum num);
  PlayerObject *GetPlayer(char side, Unum num);

  /* Player data-structure management */
  PlayerObject *GetNewPlayer(char side, Unum num);
  Bool         ForgetAPlayer(char side);
  void         CleanMyPlayers();