memposition.h

1999年卡耐基梅陇大学的2D仿真源代码

  int NumTeammatesInCone(float wid_dist_ratio, Vector end, Vector vert, Bool IncludeMe = FALSE);
  inline int NumPlayersInCone(float wid_dist_ratio, Vector end, Vector vert)
    { return NumOpponentsInCone(wid_dist_ratio, end, vert) +
	NumTeammatesInCone(wid_dist_ratio, end, vert); 
    }

  int NumOpponentsInCone(float wid_dist_ratio, Vector end)
    { return NumOpponentsInCone(wid_dist_ratio, end, MyPos()); }
  int NumTeammatesInCone(float wid_dist_ratio, Vector end)
    { return NumTeammatesInCone(wid_dist_ratio, end, MyPos()); }
  int NumPlayersInCone(float wid_dist_ratio, Vector end)
    { return NumPlayersInCone(wid_dist_ratio, end, MyPos()); }

  /* which is 'm' (my team), 't' (thier team), 'b' (both) */
  /* this should probably be private */
  int NumPlayersInConeToPlayer(char which,
			       float wid_dist_ratio, char side, Unum num,
			       float extra_len, Vector vert);

  int NumPlayersInConeToPlayer(float wid_dist_ratio, char side, Unum num, float extra_len, Vector vert)
    { return NumPlayersInConeToPlayer('b', wid_dist_ratio, side, num, extra_len, vert); }
  int NumTeammatesInConeToPlayer(float wid_dist_ratio, char side, Unum num, float extra_len, Vector vert)
    { return NumPlayersInConeToPlayer('m', wid_dist_ratio, side, num, extra_len, vert); }
  int NumOpponentsInConeToPlayer(float wid_dist_ratio, char side, Unum num, float extra_len, Vector vert)
    { return NumPlayersInConeToPlayer('t', wid_dist_ratio, side, num, extra_len, vert); }
  int NumPlayersInConeToTeammate(float wid_dist_ratio, Unum num, float extra_len, Vector vert)
    { return NumPlayersInConeToPlayer('b', wid_dist_ratio, MySide, num, extra_len, vert); }
  int NumTeammatesInConeToTeammate(float wid_dist_ratio, Unum num, float extra_len, Vector vert)
    { return NumPlayersInConeToPlayer('m', wid_dist_ratio, MySide, num, extra_len, vert); }
  int NumOpponentsInConeToTeammate(float wid_dist_ratio, Unum num, float extra_len, Vector vert)
    { return NumPlayersInConeToPlayer('t', wid_dist_ratio, MySide, num, extra_len, vert); }
  int NumPlayersInConeToOpponent(float wid_dist_ratio, Unum num, float extra_len, Vector vert)
    { return NumPlayersInConeToPlayer('b', wid_dist_ratio, TheirSide, num, extra_len, vert); }
  int NumTeammatesInConeToOpponent(float wid_dist_ratio, Unum num, float extra_len, Vector vert)
    { return NumPlayersInConeToPlayer('m', wid_dist_ratio, TheirSide, num, extra_len, vert); }
  int NumOpponentsInConeToOpponent(float wid_dist_ratio, Unum num, float extra_len, Vector vert)
    { return NumPlayersInConeToPlayer('t', wid_dist_ratio, TheirSide, num, extra_len, vert); }

  int NumPlayersInConeToPlayer(float wid_dist_ratio, char side, Unum num, float extra_len = 0.0)
    { return NumPlayersInConeToPlayer('b', wid_dist_ratio, side, num, extra_len, MyPos()); }
  int NumTeammatesInConeToPlayer(float wid_dist_ratio, char side, Unum num, float extra_len = 0.0)
    { return NumPlayersInConeToPlayer('m', wid_dist_ratio, side, num, extra_len, MyPos()); }
  int NumOpponentsInConeToPlayer(float wid_dist_ratio, char side, Unum num, float extra_len = 0.0)
    { return NumPlayersInConeToPlayer('t', wid_dist_ratio, side, num, extra_len, MyPos()); }
  int NumPlayersInConeToTeammate(float wid_dist_ratio, Unum num, float extra_len = 0.0)
    { return NumPlayersInConeToPlayer('b', wid_dist_ratio, MySide, num, extra_len, MyPos()); }
  int NumTeammatesInConeToTeammate(float wid_dist_ratio, Unum num, float extra_len = 0.0)
    { return NumPlayersInConeToPlayer('m', wid_dist_ratio, MySide, num, extra_len, MyPos()); }
  int NumOpponentsInConeToTeammate(float wid_dist_ratio, Unum num, float extra_len = 0.0)
    { return NumPlayersInConeToPlayer('t', wid_dist_ratio, MySide, num, extra_len, MyPos()); }
  int NumPlayersInConeToOpponent(float wid_dist_ratio, Unum num, float extra_len = 0.0)
    { return NumPlayersInConeToPlayer('b', wid_dist_ratio, TheirSide, num, extra_len, MyPos()); }
  int NumTeammatesInConeToOpponent(float wid_dist_ratio, Unum num, float extra_len = 0.0)
    { return NumPlayersInConeToPlayer('m', wid_dist_ratio, TheirSide, num, extra_len, MyPos()); }
  int NumOpponentsInConeToOpponent(float wid_dist_ratio, Unum num, float extra_len = 0.0)
    { return NumPlayersInConeToPlayer('t', wid_dist_ratio, TheirSide, num, extra_len, MyPos()); }

  Unum ClosestTeammateTo(Vector p, Bool include_me = TRUE);
  Unum ClosestOpponentTo(Vector p);
  Vector ClosestTeamlessPlayerPosition();
  Unum ClosestTeammateToBall(Bool include_me = TRUE);
  Unum ClosestOpponentToBall();
  float ClosestTeammateToBallDistance(Bool include_me = TRUE); 

  inline int NumTeammatesCloserTo(Vector p) { return NumTeammatesWithin(DistanceTo(p),p) - 1; }
  inline int NumOpponentsCloserTo(Vector p) { return NumOpponentsWithin(DistanceTo(p),p); }
  inline int NumPlayersCloserTo(Vector p)   { return NumTeammatesCloserTo(p) + NumOpponentsCloserTo(p); }
  inline int NumTeammatesCloserToBall()     { return NumTeammatesCloserTo(BallAbsolutePosition()); }
  inline int NumOpponentsCloserToBall()     { return NumOpponentsCloserTo(BallAbsolutePosition()); }
  inline int NumPlayersCloserToBall()       { return NumPlayersCloserTo(BallAbsolutePosition()); }

  float PlayerDistanceTo(char s, Unum n, Vector p);
  inline float TeammateDistanceTo(Unum n, Vector p) { return PlayerDistanceTo(MySide,n,p); }
  inline float OpponentDistanceTo(Unum n, Vector p) { return PlayerDistanceTo(TheirSide,n,p); }

  float PlayerDistance2To(char s, Unum n, Vector p);
  inline float TeammateDistance2To(Unum n, Vector p) { return PlayerDistance2To(MySide,n,p); }
  inline float OpponentDistance2To(Unum n, Vector p) { return PlayerDistance2To(TheirSide,n,p); }

  float PlayerDistanceToLine(char s, Unum n, Line l);
  inline float TeammateDistanceToLine(Unum n, Line l) { return PlayerDistanceToLine(MySide,n,l); }
  inline float OpponentDistanceToLine(Unum n, Line l) { return PlayerDistanceToLine(TheirSide,n,l); }

  float PlayerDistance2ToLine(char s, Unum n, Line l);
  inline float TeammateDistance2ToLine(Unum n, Line l) { return PlayerDistance2ToLine(MySide,n,l); }
  inline float OpponentDistance2ToLine(Unum n, Line l) { return PlayerDistance2ToLine(TheirSide,n,l); }

  inline float PlayerDistanceToBall(char side, Unum num)  
    { if (!BallPositionValid()) my_error("Ball unknown"); 
      return PlayerDistanceTo(side,num,BallAbsolutePosition()); } 
  inline float TeammateDistanceToBall(Unum num) { return PlayerDistanceToBall(MySide,num); } 
  inline float OpponentDistanceToBall(Unum num) { return PlayerDistanceToBall(TheirSide,num); } 

  /* Which side of the field is the object on? */
  inline Fside BallLocationSide() { return LocationSide(BallAbsolutePosition()); }
  inline Fside TeammateLocationSide(Unum t) { return LocationSide(TeammateAbsolutePosition(t)); }
  inline Fside OpponentLocationSide(Unum o) { return LocationSide(OpponentAbsolutePosition(o)); }
  inline Fside PlayerLocationSide(char s, Unum p) { return LocationSide(PlayerAbsolutePosition(s,p)); }

  inline Unum ClosestTeammate() 
    { if (!MyConf()) my_error("I'm lost"); return ClosestTeammateTo(MyPos(),FALSE); }
  inline Unum ClosestOpponent() 
    { if (!MyConf()) my_error("I'm lost"); return ClosestOpponentTo(MyPos()); }


  Unum FurthestBackTeammate(Bool IncludeUs = TRUE, Bool IncludeGoalie = TRUE);
  Unum FurthestBackOpponent();
  /* if we can't find any players, this will return (0,0) */
  Vector PositionOfFurthestBackPlayer(Bool IncludeUs = TRUE);

  Unum FurthestForwardTeammate(Bool IncludeUs = TRUE);
  Unum FurthestForwardOpponent(Bool IncludeGoalie = TRUE);
  /* if we can't find any players, this will return (0,0) */
  Vector PositionOfFurthestForwardPlayer(Bool IncludeUs = TRUE);

  float AngleBetweenClosestTwoOpponents(Vector p);

  Bool InOwnPenaltyArea(Vector p);
  Bool InOwnPenaltyArea();
  Bool BallInOwnPenaltyArea();
  Bool FacingBackInOwnPA();
  Bool FacingBackNearOwnGoal();

  Bool IsPointInBounds(float x, float y, float buffer=0);
  Bool IsPointInBounds(Vector pt, float buffer=0) { return IsPointInBounds(pt.x, pt.y, buffer); }
  Rectangle ShiftRectangleInBounds(Rectangle *rect);

  void update();
  void update_self_seen(Time time);
  void update_self(Time time);
  void update_ball(Time time);
  void update_players(Time time);
  void reconcile_unknown_players();

  void VerifyDash(float *dash_power);

  Vector PositionToKickoffPosition(const Vector pos);

  /* offside stuff */

  float my_offside_line;    /* In front of which I'm offside      */
  float their_offside_line; /* Behind which other team is offside */
  void  update_offside_lines();

  Bool OffsidePosition(float x, char side);
  inline Bool OffsidePosition(Vector pos, char side) { return OffsidePosition(pos.x,side); }
  Bool TeammateInOffsidePosition(Unum num);
  Bool OpponentInOffsidePosition(Unum num);
  Bool PlayerInOffsidePosition(char side, Unum num);
  inline Bool InOffsidePosition() { return TeammateInOffsidePosition(MyNumber); }
  Unum TeammateOffsideIfIKick();

  float XToAdjustForOffsideX(float x, float buffer);
  inline float XToAdjustForOffsideX(float x) { return XToAdjustForOffsideX(x,CP_at_point_buffer); }
  inline Vector PositionToAdjustForOffsidePosition(Vector pos, float buffer)
    { pos.x = XToAdjustForOffsideX(pos.x,buffer); return pos; }
  inline Vector PositionToAdjustForOffsidePosition(Vector pos)
    { pos.x = XToAdjustForOffsideX(pos.x,CP_at_point_buffer); return pos; }
  Rectangle RectangleToAdjustForOffsideRectangle(Rectangle *rect, float buffer);
  inline Rectangle RectangleToAdjustForOffsideRectangle(Rectangle *rect)
    { return RectangleToAdjustForOffsideRectangle(rect,CP_at_point_buffer); }
  
  inline float XToOnsideX(float x, float buffer) { return Min(x, my_offside_line-buffer); }
  inline float XToOnsideX(float x) { return XToOnsideX(x,CP_at_point_buffer); }

  inline Vector PositionToOnsidePosition(Vector pos, float buffer) 
    { pos.x = XToOnsideX( pos.x, buffer ); return pos; }
  inline Vector PositionToOnsidePosition(Vector pos) 
    { return PositionToOnsidePosition(pos,CP_at_point_buffer); }

  Vector PositionToPullOffsidePosition(Vector pos, float buffer);
  inline Vector PositionToPullOffsidePosition(Vector pos) 
    { return PositionToPullOffsidePosition(pos,CP_at_point_buffer); }

  Bool  PullOffside;
  float PullOffsidePosition;

  /* congestion stuff */
  
  float Congestion(Vector pos, Bool consider_me = FALSE);
  float TeammateCongestion(Unum teammate, Bool consider_me = TRUE);
  inline float MyCongestion() { return TeammateCongestion(MyNumber,FALSE); }
  Unum  LeastCongestedTeammate();
  Vector LeastCongestedValidPointInRectangle(Rectangle *rect, Bool attract = FALSE, Vector attract_point = 0);
  Vector LeastCongestedValidPointForPassFromInRectangle(Rectangle *rect, Vector from, 
					     Bool attract = FALSE, Vector attract_point = 0);

  inline void SetTeammateTired(Unum num, Time time) { TiredTimes[num] = time; }
  inline Bool TeammateTired(Unum num) 
    { 
      if ( num == MyNumber ) 
	return Tired();
      else 
	return (CurrentTime.t - CP_say_tired_interval > SecondLastStartClockTime.t &&
	      CurrentTime - CP_say_tired_interval < TiredTimes[num]) ? TRUE : FALSE; 
    }

  inline void SetAnnouncedTired(Time time) { SetTeammateTired(MyNumber,time); }
  inline Bool NeedToAnnounceTired()
    { if (!Tired()) my_error("I'm not tired"); 
      return (CurrentTime.t - CP_say_tired_interval > SecondLastStartClockTime.t &&
	      CurrentTime - CP_say_tired_interval < TiredTimes[MyNumber]) ? FALSE : TRUE; }
    
  Rectangle OwnPenaltyArea;
  Rectangle OwnGoalieArea;
  Rectangle TheirPenaltyArea;
  Rectangle TheirGoalieArea;
  Rectangle FieldRectangle;
  Vector    MyLeftGoalKickSpot;
  Vector    MyRightGoalKickSpot;
  Vector    TheirLeftGoalKickSpot;
  Vector    TheirRightGoalKickSpot;

  /* for the new position based velocity correction */
  Time   sight_position_correction_time;
  Vector sight_position_correction;

  /* for ball vcelocity invalidation */
  float quantize_err_const;
  float Tan_of_half_deg; /* the tangent of 1/2 degree */
  
private:

  Time TiredTimes[MAX_PLAYERS];

  PlayerObject *ClosestPlayerObjectTo(Vector gpos); 
  PlayerObject *ClosestTeammateObjectTo(Vector gpos);
  PlayerObject *ClosestOpponentObjectTo(Vector gpos);
  PlayerObject *ClosestPlayerObjectTo(char side, Vector gpos); 

  StationaryObject *Fieldline;
  StationaryObject *Marker;            
  BallObject       Ball;
  PlayerObject     *Player;        

  SideLine      SeenLine;
  MarkerType    SeenMarker[MAX_MARKERS];      /* for clearing the seen flag            */
  PlayerObject  *MyPlayer[MAX_PLAYERS];       /* pointers to the players on my team    */
  PlayerObject  *TheirPlayer[MAX_PLAYERS];    /* pointers to the players on their team */
  PlayerObject  *TeamlessPlayer[MAX_PLAYERS]; /* pointers to the players with no team  */
  PlayerObject  *FreePlayer[MAX_PLAYERS];     /* elements in Player not assigned       */

  TempPlayerObject  *UnknownPlayer;           /* Players seen with missing team or num */

  int num_seen_markers;
  int num_my_players;
  int num_their_players;
  int num_teamless_players;
  int num_free_players;
  int num_unknown_players;
  int num_players;         /* The maximum -- doesn't include me */
};

#endif