objects.h

2002年

#ifndef __OBJECTS_H__
#define __OBJECTS_H__


#include "types.h"
#include "geometry.h"

const int CP_num_stored_sensoryinfos = 8;
const int CP_num_stored_fullinfos = 5;
const int CP_num_stored_updateinfos = 3;
const float CP_valid_pos_delta = 30.0f;

//两个agent之间的坐标系偏差估计, 用于听觉Update
const float CP_coordinate_gap_between_agents = 0.2f;

class ObjectUpdate{
protected:
	TimedDataArray<Vector, CP_num_stored_sensoryinfos> seenposinfo;
	Index<Time, CP_num_stored_updateinfos> seen_times;
	bool seen;
	Time seentime;
	Time lastseentime;
	Time sdtime;
	ObjType objtype;
	float max_conf; // maximum confidence
	float min_valid_conf; // minimum confidence valid
	float conf_decay; // decay of confidence for each cycle
public:
	Time  pos_time;
	ObjectUpdate();
/********	Set Info	*******************/
	void set_polar(AngleDeg ang,Time time); /* set relative polar */
	void set_polar(AngleDeg ang,float d,Time time);
	void set_objtype(ObjType objtype);
	void set_conf_param(float max,float decay,float min);
/******		Seen Pos Info	*****************/
	inline Time seen_time(){ return seentime;}
	inline float seen_distance(Time t){ return seenposinfo.Data(t).x;}
	inline float seen_rel_angle(Time t){ return seenposinfo.Data(t).y;}
	inline float seen_rel_angle(){ return seenposinfo.Data(seentime).y;}
	inline float seen_distance(){ return seenposinfo.Data(seentime).x;}
	inline bool IsSeen(){return seen;}
	inline bool IsSeen(Time t){ return seenposinfo.IsDataKnown(t);}
	inline bool IsDistanceSeen(){ return sdtime == seentime;}
};

class Object : public ObjectUpdate{
public:
	Object();
/*******	Pos Info	******************/
	Vector pos;				// absolute position
	Vector rel_pos;			// relative position to me
	AngleDeg global_angle;	// relative angle to me
	float distance;			// distance from me
	float pos_conf;			//confidence of position
/*******	Set Info	******************/
	void set_pos(float X,float Y,bool rotate);// for makers
	void set_global_angle(AngleDeg ang,bool rotate);//for lines
/********	Confidence	*******************/
	virtual bool pos_valid();
};

struct FullStateObject{
	TimedDataArray<Vector,CP_num_stored_fullinfos> acc_pos;
	TimedDataArray<Vector,CP_num_stored_fullinfos> acc_vel;
};

class MobileUpdate : public FullStateObject{
protected:	
	TimedDataArray<Vector, CP_num_stored_sensoryinfos> gpos, gvel;
	Time update_seen_time;	//last seen time (set by update, used for later)
	bool forgot;			//flag that represent whether object pos is valid

	Time  coordinate_time;	//位置点采用的Self的坐标系时间 (only for update)
	/**************************/
	TimedDataArray<float, CP_num_stored_updateinfos> pos_deltas;	//位置的准确度
	Time pos_delta_time;	//(only for update)
	bool pos_delta_valid;	//validness of pos

	TimedDataArray<Vector, CP_num_stored_sensoryinfos> seenchinfo;	
/***********obtained domain************************************/
public:	
	TimedDataArray<RingSector, 4> domain; //possible area of a player
protected:
	bool updated_seen;		//set by update, used for decision
	bool newpos;	//whether new pos info got (both viusal and audio)
	bool newvel;	//whether new vel info got (both viusal and audio)
public:	
	bool Updated_seen(){return updated_seen;}
	bool Updated_pos(){return newpos;}	
	bool Updated_vel(){return newvel;}
protected:
	Time domain_time;	//(only for update)
	
/*******	information heard	******************/
	bool heard_pos, heard_vel;	//(set by parse, only used by update)
	bool isupdateheard;			//whether heard info is taken by update
	TimedData<NoiseVector> heardpos_info;	//(set by parse, only used by update)
	TimedData<NoiseVector> heardvel_info;	//(set by parse, only used by update)

	void estimate_pos_delta(Time t);
public:	
	MobileUpdate();
	Time   vel_time;	//(only used by update)
	float speed_decay;	// speed decay (param of player)
	float max_speed;	// maximum speed (param of player)
	float pos_delta;	// approximate delta value	of pos

	void set_speed_param(float max,float decay);
/*************************************/
	void set_chinfo(float distch,float dirch,Time time); /* set infomation about change */

	void Parse_HearPos(TimedData<NoiseVector>& hearpos);
	void Parse_HearVel(TimedData<NoiseVector>& hearvel);	
/*************************************/
	inline float seen_distCh(Time time){ return seenchinfo.Data(time).x;}
	inline float seen_dirCh(Time time){ return seenchinfo.Data(time).y;}
	inline bool IsSeenMoving(Time t){ return seenchinfo.IsDataKnown(t);}
};

class MobileObject : public Object, public MobileUpdate{
public:
	MobileObject();
/*************************************/
	void FullSee(const Vector& pos, const Vector& vel, int time){
		acc_pos.Setdata(pos, time);
		acc_vel.Setdata(vel, time);
		seen = true;
	}
/*************************************/
	Vector Pos(Time time);
	Vector Vel(Time time);
	float ActiveRadius(Time time);

	Time Last_seen_time(){ return update_seen_time;}
	bool IsLastSeen();		//whether seen in last sight info
	inline bool Isforgot(){return forgot;}
	inline bool IsValidObject(){return pos_delta_valid;}
	inline void ForceInValid(){
		pos_delta_valid = false;
		pos_conf = 0;
		domain.Data(domain_time).ForceInValid();
	}
	int VelDelay();
	int PosDelay();
/*********	Velocity	*************/
	Vector global_vel;	//global vel(set by update)
	float  vel_angle;	//angle of global_vel(set by update)
	float speed;		//length of global_vel(set by update)
	float speed_conf;	//confidence of vel
	bool speed_valid();
	
	Time original_postime;	//correct pos time(last seen time or heard-seen time)
	Time original_veltime;	//correct vel time(last seen time or heard-seen time)

/************	update	******************/	
	virtual void Prior_update();
	void update(Time time);
	virtual void update_seen(Time time);
	virtual void update_heard(Time time);
	virtual bool Isupdate_heard();
	virtual void update_end();
	void estimate_vel(Time time);
	virtual void estimate_pos(Time time);
	virtual void estimate(Time time);
	bool inview(Time time);
	void forget();
/********	Position Predicted	***********/
	Vector  PredictPos(int);
	void  PredictPos(Vector p[], int cycles);

	float MinDist(const Vector& tpos);
	float Max_posx();			//considering domain and pos_delta
	float Min_posx();			
/***********Sensitivity buffer************************************/
	TimedDataArray<float, CP_num_stored_sensoryinfos> offsensitivity;
	TimedDataArray<float, CP_num_stored_sensoryinfos> defsensitivity;

	float GetOffsensitivity();
	float GetOffsensitivity(Time t);
	float GetDefsensitivity();
	float GetDefsensitivity(Time t);
};

class Ball : public MobileObject{
private:
	Time posgap_time;
	Time velgap_time;
	TimedDataArray<Vector, CP_num_stored_sensoryinfos> ClosestRPos;
	TimedDataArray<UNum, CP_num_stored_sensoryinfos> ClosestPlayer;
	Vector posbased_vel_estimate(Time prev_time, Time last_time, bool& valid);
	TimedDataArray<float, CP_num_stored_sensoryinfos> error_idx;
	bool kick_able;
	bool find_kick;
	float theirgoalangle, mygoalangle;
public:
	Ball();
	float TheirGoalAngle(){return theirgoalangle;}
	float MyGoalAngle(){return mygoalangle;}
	bool Isupdate_heard();
	void Prior_update();
	void update_heard(Time time);
	void update_seen(Time time);	
	void update_end();
	void estimate(Time time);
	void estimate_pos(Time time);
	void CollisionHandle(Time time);
	void ApplyPosbased_vel(Time prevtime,Time latestime,float conf);
	void Collisionvel(Time time,float conf);
	
	inline bool kickable(){return kick_able;}
	inline bool kickable(const Vector& selfpos);
	bool catchable();//{ return bool(PitchInfo.shootablearea.IsWithin(pos) && kickable());}
	bool catchable(const Vector& selfpos);
	bool shootable();//{ return bool(PitchInfo.shootablearea.IsWithin(pos) && kickable());}
	bool shootable(const Vector& ballpos);
	//bool inforbiddenzone();
	void update_seengap(Time t);
	void estimategap(Time t);
	int SeenGap(Time t,Vector& posgap,Vector* velgap = NULL);
	bool IsposError(Vector allowposgap, Vector predictgap,float& gapmod);
	bool OtherKick(Time time);
	bool OtherKick(Time prevtime,Time lastime);
	bool Find_Kick(){return find_kick;}

	void Setball_CPlayer(UNum idx,Vector pos,Time time);
	inline bool IscplayerKnown(Time time){return ClosestPlayer.IsDataKnown(time);}
	inline bool IscrposKnown(Time time){return ClosestRPos.IsDataKnown(time);}
	inline UNum closestplayer(Time time){return ClosestPlayer.Data(time);}
	inline Vector closestrpos(Time time){return ClosestRPos.Data(time);}

	/******************************/
	TimedData<bool> heardpass;
	bool updated_holder;
	bool IsOtherKick(Time t);
	bool IsOtherKick();
	
	TimedDataArray<Vector, CP_num_stored_sensoryinfos> posgap, velgap;
};


#endif //__OBJECTS_H__