sensory.cpp

RoboCup仿真组世界冠军源代码

		MyPlayer(NO).set_polar(ang,dist,time);
		MyPlayer(NO).set_chinfo(distChng,dirChng,time);
		MyPlayer(NO).set_fcinfo(facedir, neckdir,time);	
		IdentifyMyGoalie(NO, IsGoalie);
	}
	else{
		TheirPlayer(NO).set_polar(ang,dist,time);
		TheirPlayer(NO).set_chinfo(distChng,dirChng,time);
		TheirPlayer(NO).set_fcinfo(facedir, neckdir,time);
		IdentifyTheirGoalie(NO, IsGoalie);
	}
}

void Sensory::IdentifyMyGoalie(UNum No,bool IsGoalie){
	MyPlayer(No).Is_goalie = IsGoalie;
	if(IsGoalie) fieldinfo.mygoalie = No;
} 

void Sensory::IdentifyTheirGoalie(UNum No,bool IsGoalie){
	TheirPlayer(No).Is_goalie = IsGoalie;
	if(IsGoalie) fieldinfo.theirgoalie = No;
}
/*******************************************************************************/

void Sensory::Update(){

	situation.UpdateTime(LatestTime) ;

	if ( NewSight && LastSightTime < situation.CurrentTime - 1 && !situation.ClockStopped){
    /* Special case--ignore sights from just before change to play_on_mode
       if they seem to be 2 cycles ago.  Better would be to adjust the sight
       time, but then sight times of all other objects also need to be adjusted */
		NewSight = false; /* process only recent cycles */
		if ( LastSightTime < situation.CurrentTime - 2 )
			my_error("Last sight shouldn't be so out of date");
	}
	
	action.ActionsInvalidation(); // is the last cycle actions taking effect?
	Self.update(situation.CurrentTime);
	Update_others(situation.CurrentTime);

	Update_dirconf(situation.CurrentTime, NewSight);
	action.PreProcess();

	if (situation.ClockStopped)
		situation.ClockStoppedTime ++;
	Reset();
	situation.SightTime = sensory.LastSightTime;

	situation.UpdateMode();
}

void Sensory::Update_dirconf(Time time, bool NewSight){
	for(int i = 0; i < CP_num_divisions; i ++){
		dir_conf[i] *= Exp(CP_conf_decay, (float)(time - dir_time));
	}
	if (NewSight){
		for(i = 0; i < CP_num_divisions; i ++){
			if (fabs(NormalizeAngle((i + 0.5f) * CP_division - Self.Headfacing(LastSightTime))) < 0.8f * sensory.MyViewAngle()){
				dir_conf[i] = CP_conf_max;
				if (LastSightTime != time)
					dir_conf[i] *= Exp(CP_conf_decay, (float)(time -LastSightTime));
			}
		}
	}
	dir_time = time;
}

void Sensory::Reset(){
	NewSight = false;
	NewSenseInfo = false;
	NewSound = false;
	TwiceSight = false;
	num_unknown_myplayers = 0;
	num_unknown_theirplayers = 0;
	num_teamlessplayers = 0;
}

float Sensory::DirConf(AngleDeg dir){
	return dir_conf[int(NormalizeAngle(dir, 0.0f) / CP_division)];
}

void Sensory::Update_others(Time time){
	if(motion.Vinfo_coming){
		if(!sensory.NewSight){
			DoLog(LOG_VDEC,"coming visual haven't come");
		}else{
		}
	}

	ball.update(time);// ball info should be updated prior to the other objs
	int i,j;
	for(i = 0; i < SP_team_size; i ++){
		MyTeam[i].update(time);
	}

	for(i = 0; i < SP_team_size; i ++){
		TheirTeam[i].update(time);
	}

	for(i = 0; i < num_unknown_theirplayers; i ++){
		if (!UnknownTheirPlayers[i].IsDistanceSeen()) continue;
		UnknownTheirPlayers[i].Reset(UnknownTheirPlayers[i].seen_time());
		UnknownTheirPlayers[i].update(time);
	}
	for(i = 0; i < num_unknown_myplayers; i ++){
		if (!UnknownMyPlayers[i].IsDistanceSeen()) continue;
		UnknownMyPlayers[i].Reset(UnknownMyPlayers[i].seen_time());
		UnknownMyPlayers[i].update(time);
	}
	for(i = 0; i < num_teamlessplayers; i ++){
		if (!TeamlessPlayers[i].IsDistanceSeen()) continue;		
		TeamlessPlayers[i].Reset(TeamlessPlayers[i].seen_time());
		TeamlessPlayers[i].update(time); 
	}
	
	unknowntheirplayerlist.update(time);
	unknownmyplayerlist.update(time);
	teamlessplayerlist.update(time);
	int idx;
	float dist, min_dist;

	if(sensory.NewSight ){
	/*	Far Player Update	*/
		Vector pos;
		for(i = num_unknown_theirplayers-1; i >= 0; i--){//descent order to reduce update when twice sight
			if (!UnknownTheirPlayers[i].IsDistanceSeen()) continue;
			idx = -1;
			min_dist = CP_too_different_distance;
			for(int j = 0; j < SP_team_size; j ++){
				if(TheirTeam[j].IsSeen(UnknownTheirPlayers[i].seen_time())) continue;
				if(TheirTeam[j].pos_conf > CP_identify_min_conf){
					dist = TheirTeam[j].pos.disaeolus(UnknownTheirPlayers[i].pos);
					if (dist < min_dist){
						idx = j;
						min_dist = dist;
					}
				}
			}
			if(idx != -1 ){
				if(TheirTeam[idx].IsSamePlayer(UnknownTheirPlayers[i])){
					if(TheirTeam[idx].seen_time() < UnknownTheirPlayers[i].seen_time()){
						TheirTeam[idx].set_polar(UnknownTheirPlayers[i].seen_rel_angle(), UnknownTheirPlayers[i].seen_distance(),UnknownTheirPlayers[i].seen_time());
						TheirTeam[idx].update(time);
					}else{
						//twice sight don't need to update;
					}
					DoLog(LOG_UNKPLAYER,"Findnum Opp %.0f pos(%.2f,%.2f)",(float)(idx+1),TheirTeam[idx].pos.x,TheirTeam[idx].pos.y);
					continue;
				}
			}
			//	Enlist in the unknownplayer list
			unknowntheirplayerlist.EnList(UnknownTheirPlayers[i]);
		}

		for(i = num_unknown_myplayers-1; i >= 0; i--){
			if (!UnknownMyPlayers[i].IsDistanceSeen()) continue;
			DoLog(LOG_UNKPLAYER,"find teammate for(%.1f,%.1f) at %d", UnknownMyPlayers[i].pos.x, UnknownMyPlayers[i].pos.y, UnknownMyPlayers[i].seen_time());
			idx = -1;
			min_dist = CP_too_different_distance;
			for(int j = 0; j < SP_team_size; j ++){
				if(MyTeam[j].IsSeen(UnknownMyPlayers[i].seen_time())) continue;
				if(MyTeam[j].pos_conf > CP_identify_min_conf){
					dist = MyTeam[j].pos.disaeolus(UnknownMyPlayers[i].pos);
					//DoLog(LOG_UNKPLAYER,"to %d(%.1f,%.1f), dis %.1f",MyTeam[j].InsideNO, MyTeam[j].Pos(seentime).x, MyTeam[j].Pos(seentime).y,dist);
					if (dist < min_dist){
						idx = j;
						min_dist = dist;
					}
				}else{
				//	DoLog(LOG_UNKPLAYER,"omit %d for conf %.1f", MyTeam[j].InsideNO,MyTeam[j].pos_conf); 
				}
			}
			
			if(idx != -1 ){
				if(MyTeam[idx].IsSamePlayer(UnknownMyPlayers[i])){
					if(MyTeam[idx].seen_time() < UnknownMyPlayers[i].seen_time()){
						MyTeam[idx].set_polar(UnknownMyPlayers[i].seen_rel_angle(), UnknownMyPlayers[i].seen_distance(),UnknownMyPlayers[i].seen_time());
						MyTeam[idx].update(time);
					}
					DoLog(LOG_UNKPLAYER,"Findnum Teammate %.0f pos(%.2f,%.2f)",(float)(idx+1),MyTeam[idx].pos.x,MyTeam[idx].pos.y);
					continue;
				}
			}
			//	Enlist in the unknownplayer list
			unknownmyplayerlist.EnList(UnknownMyPlayers[i]);
		}
	/*	Feeled Player Update	*/
		for(i = num_teamlessplayers-1; i >= 0; i--){
			if (!TeamlessPlayers[i].IsDistanceSeen()) continue;

			idx = -1;
			min_dist = CP_too_different_distance;
			if (TeamlessPlayers[i].seen_distance() > SP_feel_distance) continue;
			
			for(j = 0; j < SP_team_size; j ++){
				if(TheirTeam[j].IsSeen(TeamlessPlayers[i].seen_time())) continue;
				if(TheirTeam[j].pos_conf < CP_identify_min_conf) continue;
				dist = TheirTeam[j].pos.disaeolus(TeamlessPlayers[i].pos);
				if (dist < min_dist){
					idx = j + SP_team_size;
					min_dist = dist;
				}
			}
			
			for(j = 0; j < SP_team_size; j ++){
				if(MyTeam[j].IsSeen(TeamlessPlayers[i].seen_time())) continue;
				if(MyTeam[j].pos_conf < CP_identify_min_conf) continue;
				dist = MyTeam[j].pos.disaeolus(TeamlessPlayers[i].pos);
				if (dist < min_dist){
					idx = j;
					min_dist = dist;
				}
			}
			
			if (idx != -1 && min_dist < CP_too_different_distance){
				if (idx >= 11){
					idx -= SP_team_size;
					if(TheirTeam[idx].IsSamePlayer(TeamlessPlayers[i])){
						if(TheirTeam[idx].seen_time() < TeamlessPlayers[i].seen_time()){
							TheirTeam[idx].set_polar(TeamlessPlayers[i].seen_rel_angle(), TeamlessPlayers[i].seen_distance(), TeamlessPlayers[i].seen_time());
							TheirTeam[idx].update(time);
						}
						DoLog(LOG_UNKPLAYER,"Identify Oppnum %d pos(%.2f,%.2f)",idx+1, TheirTeam[idx].pos.x, TheirTeam[idx].pos.y);
						continue;
					}
				}else{
					if(MyTeam[idx].IsSamePlayer(TeamlessPlayers[i])){
						if(MyTeam[idx].seen_time() < TeamlessPlayers[i].seen_time()){
							MyTeam[idx].set_polar(TeamlessPlayers[i].seen_rel_angle(), TeamlessPlayers[i].seen_distance(),TeamlessPlayers[i].seen_time());
							MyTeam[idx].update(time);
						}
						DoLog(LOG_UNKPLAYER,"Identify Teammatenum%.0f pos(%.2f,%.2f)",(float)(idx+1),MyTeam[idx].pos.x,MyTeam[idx].pos.y);
						continue;
					}
				}
			}
			
			idx = -1;
			min_dist = CP_too_different_distance;
			for(j = 0; j < unknowntheirplayerlist.oldnumplayers; j++){
				if(unknowntheirplayerlist.List[j]->IsSeen(TeamlessPlayers[i].seen_time())) continue;
				dist = unknowntheirplayerlist.List[j]->pos.disaeolus(TeamlessPlayers[i].pos);
				if(dist < min_dist){
					idx = j + SP_team_size;
					min_dist = dist;
				}
			}
			for(j = 0; j < unknownmyplayerlist.oldnumplayers; j++){
				if(unknownmyplayerlist.List[j]->IsSeen(TeamlessPlayers[i].seen_time())) continue;
				dist = unknownmyplayerlist.List[j]->pos.disaeolus(TeamlessPlayers[i].pos);
				if(dist < min_dist){
					idx = j;
					min_dist = dist;
				}
			}
			if (idx != -1 && min_dist < CP_different_distance){
				if (idx >= SP_team_size){
					idx -= SP_team_size;
					if(unknowntheirplayerlist.List[idx]->IsSamePlayer(TeamlessPlayers[i])){
						if(unknowntheirplayerlist.List[idx]->seen_time() < TeamlessPlayers[i].seen_time()){
							unknowntheirplayerlist.List[idx]->set_polar(TeamlessPlayers[i].seen_rel_angle(), TeamlessPlayers[i].seen_distance(),TeamlessPlayers[i].seen_time());
							unknowntheirplayerlist.List[idx]->update(time);
						}
						DoLog(LOG_UNKPLAYER,"Find Opp (%.2f,%.2f) at %d",unknowntheirplayerlist.List[idx]->pos.x,unknowntheirplayerlist.List[idx]->pos.y,TeamlessPlayers[i].seen_time());
						continue;
					}
				}else{
					if(unknownmyplayerlist.List[idx]->IsSamePlayer(TeamlessPlayers[i])){
						if(unknownmyplayerlist.List[idx]->seen_time() < TeamlessPlayers[i].seen_time()){
							unknownmyplayerlist.List[idx]->set_polar(TeamlessPlayers[i].seen_rel_angle(), TeamlessPlayers[i].seen_distance(),TeamlessPlayers[i].seen_time());
							unknownmyplayerlist.List[idx]->update(time);
						}
						DoLog(LOG_UNKPLAYER,"Find Teammate (%.2f,%.2f) at %d",unknownmyplayerlist.List[idx]->pos.x,unknownmyplayerlist.List[idx]->pos.y,TeamlessPlayers[i].seen_time());
						continue;
					}
				}
			}
			teamlessplayerlist.EnList(TeamlessPlayers[i]);
		}
	}

	/***********************update end********************/
	ball.update_end(); 
	for(i = 0; i < SP_team_size; i ++){
		MyTeam[i].update_end();
	}
	for(i = 0; i < SP_team_size; i ++){
		TheirTeam[i].update_end();
	}

	unknowntheirplayerlist.update_end();
	unknownmyplayerlist.update_end();
	teamlessplayerlist.update_end();
	
	unknownmyplayerlist.LogList();
	unknowntheirplayerlist.LogList();
	teamlessplayerlist.LogList();
}

int Sensory::MySightInterval(){  
	int interval = SP_send_step;  
	if ( ViewWidth == VW_Narrow ) interval /= 2;  
	else if ( ViewWidth == VW_Wide ) interval *= 2;
	if ( ViewQuality == VQ_Low ) interval /=2;  
	return interval;
}

AngleDeg Sensory::MyViewWidth(VIEWWIDTH view_width){
	switch(view_width){
	case VW_Normal : return 90;
	case VW_Narrow : return 45;
	case VW_Wide   : return 180;
	}
	return 0.0f;
}

AngleDeg Sensory::MyViewAngle(VIEWWIDTH view_width){
	return MyViewWidth(view_width) / 2.0f;
}

AngleDeg Sensory::MyViewWidth(VWTime time){
	VIEWWIDTH VWidth = (time == VWT_Current) ? ViewWidth : NextViewWidth;
	return MyViewWidth(VWidth);
}


AngleDeg Sensory::MyViewAngle(VWTime time){
	return MyViewWidth(time) / 2.0f;
}

MarkerType Sensory::ClosestGoal(){
	if (Self.pos.x < 0)
		return MyGoal;
	else
		return TheirGoal;
}

MarkerType Sensory::ClosestFlag(){
	Vector gap = Self.pos - Markers[LastClosestMarker].pos;
	if (gap.mod() > 1)
		return No_Marker;
	else
		return LastClosestMarker;
}