objects.h

robocup源代码2001年清华机器人源代码

/*
    Copyright (C) 2001  Tsinghuaeolus

    Authors : ChenJiang, YaoJinyi, CaiYunpeng, Lishi

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Lesser General Public License for more details.

	If you make any changes or have any comments we would appreciate a 
	message to [e-mail].
*/

#ifndef _object
#define _object

#include "Types.h"
#include "Geometry.h"
#include "strategy.h"
#include "interception.h"

class Object{
protected:
	TimedDataArray<Vector, CP_num_stored_sensoryinfos> seenposinfo;
	bool seen;
	ObjType objtype;
	Time seentime;
	Time lastseentime;
	Time sdtime;
public:
	Object();
/******		Seen Pos Info	*****************/
	Time seen_time(){ return seentime;}
	float seen_distance(Time t){ return seenposinfo.Data(t).x;}
	float seen_rel_angle(Time t){ return seenposinfo.Data(t).y;}
	float seen_rel_angle(){ return seenposinfo.Data(seentime).y;}
	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;}
/*******	Pos Info	******************/
	Vector pos;  // global position
	Vector rel_pos; // relative position to player
	Vector rel_pos_2_bodyfacing;
	Vector rel_pos_2_headfacing;
	AngleDeg global_angle;
	AngleDeg rel_angle_2_bodyfacing; 
	AngleDeg rel_angle_2_headfacing;
	float distance; // distance from me
	Time  pos_time;
	Time  coordinate_time;
	float pos_conf; //confidence of position
/********	Confidence	*******************/
	float max_conf; // maximum confidence
	float min_valid_conf; // minimum confidence valid
	float conf_decay; // decay of confidence for each cycle
	 bool pos_valid();
/********	Set Info	*******************/
	void set_pos(float X,float Y,bool rotate);// for makers
	void set_global_angle(AngleDeg ang,bool rotate);//for lines
	void set_polar(AngleDeg ang,Time time); /* set relative polar */
	void set_polar(AngleDeg ang,float d,Time time);
	void set_conf_param(float max,float decay,float min);
	void set_objtype(ObjType objtype);
};

class MobileObject : public Object{
protected:
	TimedDataArray<Vector, CP_num_stored_sensoryinfos> seenchinfo;
	bool seenmoving;
	bool heardupdate;

	TimedDataArray<Vector, CP_num_stored_sensoryinfos> gpos, gvel, rspos;
	TimedDataArray<float, CP_num_stored_sensoryinfos> rsradius;
	bool rs_valid;
	Time rspos_time;
	Time seenchtime;
	Time update_seen_time;
	bool forgot;
public:
	MobileObject();
/*************************************/
	Time seen_chtime(){ return seenchtime;}
	float seen_distCh(Time time){ return seenchinfo.Data(time).x;}
	float seen_dirCh(Time time){ return seenchinfo.Data(time).y;}
	float seen_distCh(){ return seenchinfo.Data(seenchtime).x;}
	float seen_dirCh(){ return seenchinfo.Data(seenchtime).y;}
/*************************************/
	 Vector Pos(Time time);
	inline Vector Vel(Time time);
	float ActiveRadius(Time time);
	Time Update_seen_time(){ return update_seen_time;}
	bool IsLastSeen();
	inline bool Isforgot(){return forgot;}
	inline bool Rs_valid(){return rs_valid;}
	inline void Setvalid(bool valid){rs_valid = valid;}
/*********	Velocity	*************/
	float max_speed; // maximum speed
	float speed_decay; // speed decay
	Vector global_vel;
	Vector rel_vel;	//rotate to my facing
	float  vel_angle;
	float speed;
	float speed_conf;// confidence of speed
	bool speed_valid();
	Time   vel_time;
	
	bool newpos;
	bool newvel;
	Time original_postime;
	Time original_veltime;

	void set_chinfo(float distch,float dirch,Time time); /* set infomation about change */
	void set_speed_param(float max,float decay);
/************	update	******************/	
	void update(Time time);
	virtual void update_seen(Time time);
	virtual void update_heard(Time time);
	virtual bool Heardupdate();
	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);
/*******	information heard	******************/
	bool heard;
	TimedData<Vector> heardposinfo;
	float heard_pos_conf;
	Time heard_org_postime;
	TimedData<Vector> heardvelinfo;
	float heard_vel_conf;
	Time heard_org_veltime;
	
/***********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;
	float theirgoalangle, mygoalangle;
public:
	Ball();
	float TheirGoalAngle(){return theirgoalangle;}
	float MyGoalAngle(){return mygoalangle;}
	bool Heardupdate();
	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(fieldinfo.shootablearea.IsWithin(pos) && kickable());}
	bool catchable(const Vector& selfpos);
	bool shootable();//{ return bool(fieldinfo.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);

	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 IsOtherKick(Time t);
	bool IsOtherKick();
	
	TimedDataArray<Vector, CP_num_stored_sensoryinfos>posgap, velgap;
};

class Player : public MobileObject, public Role{
protected:
	TimedData<Vector> fcinfo;
	TimedDataArray<AngleDeg, CP_num_stored_sensoryinfos> bodyfc, headfc, headang;
public:
	Player();
	void set_fcinfo(float facedir, float neckdir, Time time);
	void set_inside_no(UNum No);
	void set_side(bool Is_myside);
	void set_side(PlayerSide playerside);
	void Reset(Time time);
	void update(Time time);
	inline AngleDeg Bodyfacing(Time time);
	 AngleDeg Headfacing(Time time);
	inline AngleDeg Headangle(Time time);
	inline bool IsBodyfacingKnown(Time time);
	inline bool IsHeadfacingKnown(Time time);
	inline bool IsHeadAngleKnown(Time time);

	void estimaters(Time time);
	void update_end();	
	bool Heardupdate();
	bool IsSamePlayer(Player& p);
/*	UNum and side	*/
	PlayerSide side;
	UNum No;
	UNum InsideNO;
	bool IsUNumKnown(){return No != -1;}
	bool IsSideKnown(){return side != Side_Unknown;}
	bool IsMyside(){return bool(side == Side_My);}
	bool IsOppside(){return bool(side == Side_Opp);}

	bool Is_goalie;

	float stamina;
	float effort;
	float recovery;
	AngleDeg bodyfacing;
	AngleDeg head_angle;
	AngleDeg headfacing;
	
	bool IsStrained();
	bool IsExtremStrained();
/*****	relating to ball	***********/
	bool Iscontrolball;
	Vector rel_pos_2_ball;
	float balldist;//distance to ball
	AngleDeg ballangle;
	float control_of_ball;
	InterceptionInfo IT_inf;// interception infomation
	bool heard_iscontrolball;
	void Set_Iscontrolball_Fromheard(Time time);
};

class MySelf : public Player{
private:
	TimedDataArray<float, CP_num_stored_sensoryinfos> stmn, efft, spd, spdang;
	TimedDataArray<bool, CP_num_stored_sensoryinfos> selfcoll;
public:
	MySelf();
	void update(Time time);
	void update_from_senseinfo(SenseBodyInfo& sb);
	void update_seen_facing(Time time);
	void update_seen_pos(Time time);
	void update_vel(Time time);
	void estimate_facing(Time time);
	void estimate_headangle(Time time);
	void estimate_stamina(Time time);
	void estimate_effort(Time time);
	void estimate_pos(Time time);
	TimedDataArray<Vector, CP_num_stored_sensoryinfos> pos_gap;// gaps between estimate pos and sighted pos	

	inline float Speed(Time time);
	inline AngleDeg SpeedAngle(Time time);
	inline float Stamina(Time time);
	inline float Effort(Time time);
	bool SelfColl(Time prevtime,Time lastime);
	inline bool IsSpeedKnown(Time time);
	inline bool IsSpeedAngleKnown(Time time);
	inline bool IsStaminaKnown(Time time);
	inline bool IsEffortKnown(Time time);
	Vector SummarizeVelPos(Time prev, Time last);
	Vector SummarizePosGap(Time prev, Time last);
	
/*********	Predice	********************************/
	Vector  PredictPos(float dash_pow, int cycles = 1);
	Vector  PredictPos(int cycles = 1);
	Vector  PredictPosWithTurnDash(AngleDeg angle, float dash_pow);
	
	TimedDataArray<VIEWWIDTH, 3> viewwidth;
	TimedDataArray<VIEWQUALITY, 3> viewqual;
};

class UnknownPlayerList;
class UnknownPlayerNode{
private:
	Player unknownplayer;
	UnknownPlayerNode* next;
public:
	UnknownPlayerNode();
	friend UnknownPlayerList;
};

class UnknownPlayerList{
private:
	UnknownPlayerNode Head;
	UnknownPlayerNode* Tail;
	
	PlayerSide side;
public:	
	UnknownPlayerList();
	~UnknownPlayerList();
	int numplayers;
	int oldnumplayers;
	Player* List[SP_team_size];
	inline bool IsMyside(){return bool(side == Side_My);}
	inline bool IsOppside(){return bool(side == Side_Opp);}
	inline bool IsUnknownside(){return bool(side == Side_Unknown);}
	bool IsIdxValid(int idx){return idx >= 0 && idx < numplayers && List[idx] != NULL;}
	void set_side(PlayerSide playerside){side=playerside;}
	void update(Time time);
	void update_end();
	void EnList(Player& player);
	void ArraySet(Player* player);
	bool Clearable(Player& player);
	int NumUnknownPlayers();
	void Set_IsControlball_FromHeard(Time time);

	void LogList(char* msg = NULL);
};

#endif