memposition.h

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

  AngleDeg get_rel_to_body_body_ang();
  AngleDeg get_rel_to_body_neck_ang();
  AngleDeg get_rel_to_neck_body_ang();
  AngleDeg get_rel_to_neck_neck_ang();
  
  AngleDeg get_neck_rel_ang(); /* The player's relative neck angle */

  /* Methods to get the velocity */
  inline AngleDeg get_abs_body_ang() /* global   */
    { if (!body_ang_valid()) my_error ("can't get_abs_body_ang %d",type); return gbang; } 
  inline AngleDeg get_abs_neck_ang() /* global   */
    { if (!neck_ang_valid()) my_error ("can't get_abs_neck_ang %d",type); return gnang; } 
  inline float  body_ang_valid() { return ( (gbaconf >= min_valid_conf) ? gbaconf : 0 ); }
  inline float  neck_ang_valid() { return ( (gnaconf >= min_valid_conf) ? gnaconf : 0 ); }

  /* Methods to change the position                      */
  /* Changes do NOT take effect until update() is called */
  void set_body_ang_from_neck                 (AngleDeg body_ang, Time time);
  void set_neck_ang_from_neck                 (AngleDeg neck_ang, Time time);
  inline void set_body_and_neck_ang_from_neck (AngleDeg body_ang, AngleDeg neck_ang, Time time)
    { set_body_ang_from_neck(body_ang,time); set_neck_ang_from_neck(neck_ang,time); }

  void set_heard_info_w_angs (float x, float y, float pconf, float dx, float dy, float vconf, 
				  AngleDeg bang, float bconf, AngleDeg nang, float nconf, 
			          float dist, Time time);

  /* Method which processes all changes */
  void  update(Time time);
  void  update_seen_body_and_neck_angs(Time time);
  void  update_estimate(Time time);
  void  update_heard(Time time);
  void  reset();
  void  clear_seen();
  void  forget();
  void  sanitize_times();

  /* This is a pure virtual MobileObject fn.  Shouldn't be called for playerobject */
  inline void update_kick(Time time) { my_error("Can't kick players %d",time.t); }

protected:
  Bool  in_view_range(AngleDeg view_ang, float angle_buffer, float distance_buffer);

private:

  Bool     seen_body_ang;
  Bool     heard_body_ang;
  Bool     seen_neck_ang;
  Bool     heard_neck_ang;

  AngleDeg rnbang;  /* relative to neck body angle */
  Time     rnbatime;
  AngleDeg rnnang;  /* relative to neck neck angle */
  Time     rnnatime;

  AngleDeg gbang;  /* global body angle */
  float    gbaconf;
  Time     gbatime;
  AngleDeg gnang;  /* global neck angle */
  float    gnaconf;
  Time     gnatime;

  AngleDeg hbang;  /* heard body angle (global) */
  float    hbaconf;
  float    hbadist;
  Time     hbatime;
  AngleDeg hnang;  /* heard neck angle (global) */
  float    hnaconf;
  float    hnadist;
  Time     hnatime;
};


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

class TempPlayerObject {
public:

  float    dist;  /* relative */
  AngleDeg ang_from_neck;

  Time     time;
  char     side;

  inline void set(char s, float d, float a, Time t) { time = t; side = s; dist = d; ang_from_neck = 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 bodydir, float neckdir, 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 bang, float bconf, AngleDeg nang, float nconf, float dist, Time time);

  /* Access shortcuts -- Markers */
  inline float    MarkerDistance     (MarkerType m) { return GetMarker(m)->get_dist();  }
  inline float    MarkerDistance2     (MarkerType m) { return Sqr(GetMarker(m)->get_dist());  }
  inline AngleDeg MarkerAngleFromBody(MarkerType m) { return GetMarker(m)->get_ang_from_body();   }
  inline AngleDeg MarkerAngleFromNeck(MarkerType m) { return GetMarker(m)->get_ang_from_neck();   }
  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 BallAngleFromBody() { return GetBall()->get_ang_from_body();}
  inline AngleDeg BallAngleFromNeck() { return GetBall()->get_ang_from_neck();}
  inline Vector   BallAbsolutePosition() { return GetBall()->get_abs_pos();   }
  inline Vector   BallRelativeToBodyPosition() { return GetBall()->get_rel_to_body_pos();   }
  inline Vector   BallRelativeToNeckPosition() { return GetBall()->get_rel_to_neck_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 BallRelativeToBodyHeading() { return GetBall()->get_rel_to_body_heading(); }  
  inline AngleDeg BallRelativeToNeckHeading() { return GetBall()->get_rel_to_body_heading(); }  
  inline AngleDeg BallAbsoluteHeading() { return GetBall()->get_abs_heading(); }  
  inline Vector   BallRelativeToBodyVelocity() { return GetBall()->get_rel_to_body_vel();    }  
  inline Vector   BallRelativeToNeckVelocity() { return GetBall()->get_rel_to_neck_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 PlayerAngleFromBody   (char s, Unum n) 
    { return (s==MySide && n==MyNumber) ? 0                         : GetPlayer(s,n)->get_ang_from_body();  }
  inline AngleDeg PlayerAngleFromNeck   (char s, Unum n) 
    { return (s==MySide && n==MyNumber) ? 0                         : GetPlayer(s,n)->get_ang_from_neck();  }
  inline Vector   PlayerAbsolutePosition(char s, Unum n) 
    { return (s==MySide && n==MyNumber) ? MyPos()                   : GetPlayer(s,n)->get_abs_pos(); }
  inline Vector   PlayerRelativeToBodyPosition(char s, Unum n) 
    { return (s==MySide && n==MyNumber) ? Vector(0,0)               : GetPlayer(s,n)->get_rel_to_body_pos(); }
  inline Vector   PlayerRelativeToNeckPosition(char s, Unum n) 
    { return (s==MySide && n==MyNumber) ? Vector(0,0)               : GetPlayer(s,n)->get_rel_to_neck_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 PlayerRelativeToBodyHeading (char s, Unum n) 
    { return (s==MySide && n==MyNumber) ? 0                 : GetPlayer(s,n)->get_rel_to_body_heading(); }  
  inline AngleDeg PlayerRelativeToNeckHeading (char s, Unum n) 
    { return (s==MySide && n==MyNumber) ? 0                 : GetPlayer(s,n)->get_rel_to_neck_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   PlayerRelativeToBodyVelocity(char s, Unum n) 
    { return (s==MySide && n==MyNumber) ? Polar2Vector(MySpeed(),0) : GetPlayer(s,n)->get_rel_to_body_vel();}
  inline Vector   PlayerRelativeToNeckVelocity(char s, Unum n) 
    { return (s==MySide && n==MyNumber) ? Polar2Vector(MySpeed(),0) : GetPlayer(s,n)->get_rel_to_neck_vel();}
  float    PlayerVelocityValid          (char s, Unum n); 
  inline AngleDeg PlayerRelativeToBodyBodyAngle  (char s, Unum n) 
    { return (s==MySide && n==MyNumber) ? 0              : GetPlayer(s,n)->get_rel_to_body_body_ang();    }  
  inline AngleDeg PlayerRelativeToNeckBodyAngle  (char s, Unum n) 
    { return (s==MySide && n==MyNumber) ? 0              : GetPlayer(s,n)->get_rel_to_neck_body_ang();    }  
  inline AngleDeg PlayerRelativeToBodyNeckAngle  (char s, Unum n) 
    { return (s==MySide && n==MyNumber) ? 0              : GetPlayer(s,n)->get_rel_to_body_neck_ang();    }  
  inline AngleDeg PlayerRelativeToNeckNeckAngle  (char s, Unum n) 
    { return (s==MySide && n==MyNumber) ? 0              : GetPlayer(s,n)->get_rel_to_neck_neck_ang();    }  
  inline AngleDeg PlayerRelativeNeckAngle (char s, Unum n) 
    { return (s==MySide && n==MyNumber) ? 0              : GetPlayer(s,n)->get_neck_rel_ang();    }  
  inline AngleDeg PlayerAbsoluteBodyAngle    (char s, Unum n) 
    { return (s==MySide && n==MyNumber) ? MyBodyAng()               : GetPlayer(s,n)->get_abs_body_ang(); }  
  float    PlayerBodyAngleValid              (char s, Unum n);
  inline AngleDeg PlayerAbsoluteNeckAngle    (char s, Unum n) 
    { return (s==MySide && n==MyNumber) ? MyNeckGlobalAng()         : GetPlayer(s,n)->get_abs_neck_ang(); }  
  float    PlayerNeckAngleValid              (char s, Unum n);

  /* Access shortcuts -- Teammates */
  inline float    TeammateDistance        (Unum n) { return PlayerDistance        (MySide,n); }
  inline AngleDeg TeammateAngleFromBody   (Unum n) { return PlayerAngleFromBody   (MySide,n); }
  inline AngleDeg TeammateAngleFromNeck   (Unum n) { return PlayerAngleFromNeck   (MySide,n); }
  inline Vector   TeammateAbsolutePosition(Unum n) { return PlayerAbsolutePosition(MySide,n); }
  inline Vector   TeammateRelativeToBodyPosition(Unum n) { return PlayerRelativeToBodyPosition(MySide,n); }
  inline Vector   TeammateRelativeToNeckPosition(Unum n) { return PlayerRelativeToNeckPosition(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 TeammateRelativeToBodyHeading (Unum n) { return PlayerRelativeToBodyHeading (MySide,n); }
  inline AngleDeg TeammateRelativeToNeckHeading (Unum n) { return PlayerRelativeToNeckHeading (MySide,n); }
  inline AngleDeg TeammateAbsoluteHeading (Unum n) { return PlayerAbsoluteHeading (MySide,n); }
  inline Vector   TeammateAbsoluteVelocity(Unum n) { return PlayerAbsoluteVelocity(MySide,n); }
  inline Vector   TeammateRelativeToBodyVelocity(Unum n) { return PlayerRelativeToBodyVelocity(MySide,n); }
  inline Vector   TeammateRelativeToNeckVelocity(Unum n) { return PlayerRelativeToNeckVelocity(MySide,n); }
  inline float    TeammateVelocityValid   (Unum n) { return PlayerVelocityValid   (MySide,n); }
  inline AngleDeg TeammateRelativeToBodyBodyAngle(Unum n) { return PlayerRelativeToBodyBodyAngle (MySide,n); }
  inline AngleDeg TeammateRelativeToNeckBodyAngle(Unum n) { return PlayerRelativeToNeckBodyAngle (MySide,n); }
  inline AngleDeg TeammateRelativeToBodyNeckAngle(Unum n) { return PlayerRelativeToBodyNeckAngle (MySide,n); }
  inline AngleDeg TeammateRelativeToNeckNeckAngle(Unum n) { return PlayerRelativeToNeckNeckAngle (MySide,n); }
  inline AngleDeg TeammateRelativeNeckAngle    (Unum n) { return PlayerRelativeNeckAngle (MySide,n); }
  inline AngleDeg TeammateAbsoluteBodyAngle    (Unum n) { return PlayerAbsoluteBodyAngle    (MySide,n); }
  inline float    TeammateBodyAngleValid       (Unum n) { return PlayerBodyAngleValid       (MySide,n); }
  inline AngleDeg TeammateAbsoluteNeckAngle    (Unum n) { return PlayerAbsoluteNeckAngle    (MySide,n); }
  inline float    TeammateNeckAngleValid       (Unum n) { return PlayerNeckAngleValid       (MySide,n); }

  /* Access shortcuts -- Opponents */
  inline float    OpponentDistance        (Unum n) { return PlayerDistance        (TheirSide,n); }