df_positioning.cpp

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

	motion.Block_Net.SimulateNet(&input[0], &output);
	output = (output - 0.1) * 1.25;
	if	(MyPlayer(defender).IsForward())
			output =0.5 + (output + TheirPlayer(defendee).GetOffsensitivity())/4;
	return (float)output;

}

float DF_Arrangement::getpresspriority(){
	double input[3], output;
	input[0] = threat;
	pos_dist = TheirPlayer(defendee).pos.dist(MyPlayer(defender).pos);
	deviation_dist = Min(TheirPlayer(defendee).pos.dist(fm_pos),df_point.dist(fm_pos));
	input[1] = deviation_dist / CP_deviation_max;
	input[2] = pos_dist / CP_deviation_max;
	motion.Press_Net.SimulateNet(&input[0], &output);
	output = (output - 0.1) * 1.25;
	if	(MyPlayer(defender).IsForward())
			output =0.5 + (output + TheirPlayer(defendee).GetOffsensitivity() )/4;
	return (float)output;


}

float DF_Arrangement::getmarkpriority(){
	double input[3], output;
	input[0] = threat;
	pos_dist = df_point.dist(MyPlayer(defender).pos);
	deviation_dist = df_point.dist(fm_pos);
	input[1] = deviation_dist / CP_deviation_max;
	input[2] = pos_dist / CP_deviation_max;
	motion.Mark_Net.SimulateNet(&input[0], &output);
	return float((output - 0.1) * 1.25);
}
void DF_Arrangement::setdfinfo(){
	fm_pos = fm.GetDefensivePoint(MyPlayer(defender), situation.NextControlBallPos());
	if (df_type == DF_Formation)
		threat = fieldinfo.GetDefensiveSensitivity(df_point);
	else
		threat = fieldinfo.CalcThreat(defendee);
	setpriority();
}

bool DF_Arrangement::Arrange_DF_for(UNum defender, UNum defendee){
	if (!IsMyPlayer(defender) || !MyPlayer(defender).IsRoleKnown()) return false;
	this->defender = defender;
	this->defendee = defendee;
	if (defendee == DF_FORMATION_DEFENDEE){
	//Defend formation
		df_type = DF_Formation;
		return Arrange_DF_Formation_for(defender);
	}
	else{
		if (!IsTheirPlayer(defendee))
			return false;
		if (!Rect(MyPlayer(defender).pos, df_size).IsWithin(TheirPlayer(defendee).pos))
			return false;
		if (situation.IsControllerOrFutureController(situation.TheirSide, defendee)){
			df_type = DF_Block;
			 if (Arrange_DF_Block_for(defender, defendee))
			 {
				 return true;
			 }
			 else
			 {
				 df_type = DF_Press;
				 return Arrange_DF_Press_for(defender,defendee);
			 }
		}
		else{		
			df_type = DF_Mark;
			return Arrange_DF_Mark_for(defender, defendee);
		}
	}
	return false;
}

bool DF_Arrangement::Arrange_DF_Formation_for(UNum defender){
	if (!IsMyPlayer(defender) || !MyPlayer(defender).IsRoleKnown()) return false;
	df_point = fm.GetDefensivePoint(MyPlayer(defender).attackness, MyPlayer(defender).leftness, situation.NextControlBallPos());
	setdfinfo();
	return true;
}

bool DF_Arrangement::Arrange_DF_Press_for(UNum defender, UNum defendee){
	if (!getpressposition(defender,defendee,df_point))
		return false;
	setdfinfo();
	return true;
}

bool DF_Arrangement::Arrange_DF_Block_for(UNum defender, UNum defendee){
	if (!getblockposition(defender, defendee, df_point))
		return false;
	setdfinfo();
	return true;
}

bool DF_Arrangement::Arrange_DF_Mark_for(UNum defender, UNum defendee){
	if (!getmarkposition(defender, defendee, situation.NextControlBallPos(), df_point))
		return false;
	setdfinfo();
	return true;
}

bool DF_Arrangement::operator == (const DF_Arrangement& rhs){
	return this->priority == rhs.priority;
}

bool DF_Arrangement::operator > (const DF_Arrangement& rhs){
	return this->priority > rhs.priority;
}

bool DF_Arrangement::operator >= (const DF_Arrangement& rhs){
	return this->priority >= rhs.priority;
}

bool DF_Arrangement::operator < (const DF_Arrangement& rhs){
	return this->priority < rhs.priority;
}

bool DF_Arrangement::operator <= (const DF_Arrangement& rhs){
	return this->priority <= rhs.priority;
}

bool DF_Arrangement::IsMutex(const DF_Arrangement& arrangement){
	return (this->defender == arrangement.defender)
		||	(this->defendee == arrangement.defendee && df_type != DF_Formation);
}

/***********	Defensive positioning	***********************/
DF_positioning::DF_positioning(){
	num_arrangements = 0;
}

void DF_positioning::AddDF_Arrangement(const DF_Arrangement& arrangement){
	if (arrangement.valid && (arrangement.priority >= 0.4f ||arrangement.df_type == DF_Block)){
		Order_of_arrangements[num_arrangements] = num_arrangements;
		DoLog(LOG_POSITIONING, "Add arrangement defender %d defendee %d pos_dist %.2f threat %.2f deviation %.2f point (%.2f %.2f) priority %.2f", 
			arrangement.defender, arrangement.defendee, arrangement.pos_dist, 
			arrangement.threat,arrangement.deviation_dist,
			arrangement.df_point.x, arrangement.df_point.y,
			arrangement.priority);
		arrangements[num_arrangements++] = arrangement;	
	}
}



void DF_positioning::ResetBuffer(){
	num_arrangements = 0;
	max_nonmutexs = 0;
	num_scheme_members = 0;
	block_applied_count = 0;
}

DF_Arrangement& DF_positioning::Arrangement(int idx){
	idx = (idx % MAX_DF_ARRANGEMENTS) >= 0 ? 
		(idx % MAX_DF_ARRANGEMENTS) : (idx % MAX_DF_ARRANGEMENTS) + MAX_DF_ARRANGEMENTS;
	return arrangements[Order_of_arrangements[idx]];
}

void DF_positioning::SortArrangements(){
	for(int i = 0; i < num_arrangements - 1; i ++)
		for(int j = i + 1; j < num_arrangements; j ++){
			if (Arrangement(j) > Arrangement(i)){
				Swap(Order_of_arrangements[i], Order_of_arrangements[j]);
			}
		}
}

bool DF_positioning::Do_arranging(){
	SortArrangements();
	int i, j, nonmutexs_test, tmp;
//set mutexs(for a fast searching)
	max_nonmutexs = 0;
	nonmutexs_test = 0;
	for(i = 0; i < num_arrangements; i ++){
		if (!((tmp = 1 << Arrangement(i).defender) & nonmutexs_test)){
			max_nonmutexs ++;
			nonmutexs_test |= tmp;
		}
		num_mutexs[i] = 0;
	}

	for(i = 0; i < num_arrangements - 1; i ++){
		for(j = i + 1; j < num_arrangements; j ++){
			if(Arrangement(i).IsMutex(Arrangement(j))){
				mutexs[i][num_mutexs[i]++] = j;
				mutexs[j][num_mutexs[j]++] = i;
			}
		}
	}
	num_scheme_members = 0;
	block_applied_count = 0;
	max_priority_sum = 0.0f;
	Searchfor_Scheme(0.0f);
	if (max_priority_sum == 0.0f){
		DoLog(LOG_POSITIONING, "no solution!");
		return false;
	}
	else{
		for(i = 0;  i < max_nonmutexs; i ++){
			if (Arrangement(optimal_scheme[i]).df_type == DF_Formation){
				DoLog(LOG_POSITIONING, "%d fm with %.2f %d", Arrangement(optimal_scheme[i]).defender, Arrangement(optimal_scheme[i]).priority, optimal_scheme[i]);
			}
			else{
				DoLog(LOG_POSITIONING, "%d-%d with %.2f %d", Arrangement(optimal_scheme[i]).defender, Arrangement(optimal_scheme[i]).defendee, Arrangement(optimal_scheme[i]).priority, optimal_scheme[i]);
			}
		}
		return true;
	}
	return false;
}

void DF_positioning::Searchfor_Scheme(float priority_sum){
	int idx = num_scheme_members > 0 ? scheme_members[num_scheme_members - 1] + 1: 0;
	int i;
	if(num_scheme_members >= max_nonmutexs){
		return;
	}

	bool is_mutex_set[2 * SP_team_size];
	while(idx <= num_arrangements + num_scheme_members - max_nonmutexs){
		if (Arrangement(idx).valid){
			scheme_members[num_scheme_members] = idx;

			if (num_scheme_members + 1 == max_nonmutexs){
				priority_sum += Arrangement(idx).QueryPriority(block_applied_count > 0);
				if (priority_sum > max_priority_sum){
					max_priority_sum = priority_sum;
					for(i = 0; i < num_scheme_members + 1; i ++)
						optimal_scheme[i] = scheme_members[i];
				}
				return;
			}


			if (priority_sum < max_priority_sum){
				float test_priority = priority_sum;
				for(i = 0; i < max_nonmutexs - num_scheme_members; i ++){
					test_priority += Arrangement(idx+i).QueryPriority(block_applied_count > 0);
				}

				if (test_priority < max_priority_sum)
					return;
			}

			num_scheme_members ++;

			for(i = 0; i < num_mutexs[idx]; i ++){
				if (mutexs[idx][i] > idx && Arrangement(mutexs[idx][i]).valid){
					Arrangement(mutexs[idx][i]).valid = false;
					is_mutex_set[i] = true;
				}
				else{
					is_mutex_set[i] = false;
				}
			}

			if (Arrangement(idx).df_type == DF_Block){
				block_applied_count ++;
			}

			Searchfor_Scheme(priority_sum + Arrangement(idx).QueryPriority(block_applied_count > 0));

			for(i = 0; i < num_mutexs[idx]; i ++){
				if (is_mutex_set[i]){
					Arrangement(mutexs[idx][i]).valid = true;
				}
			}

			if (Arrangement(idx).df_type == DF_Block){
				block_applied_count --;
			}

			num_scheme_members --;
		}
		idx ++;
	}
	return;
}

bool DF_positioning::MakeDefenseDecision(){
	ResetBuffer();
	int num_my, num_opp, i, j;
	num_my  = motion.Num_MyVisiblePlayers();
	num_opp = motion.Num_TheirVisiblePlayers();
	if (!Self.IsForward()){
		for(j = 0; j < num_opp; j ++){
			if (situation.IsControllerOrFutureController(situation.TheirSide,motion.TheirPlayers_Close2Me[j]) && situation.gamestate == GS_Their_PlaceKick)
					continue;
			AddDF_Arrangement(DF_Arrangement(MyNumber,
				motion.TheirPlayers_Close2Me[j]));
		}
	}

	AddDF_Arrangement(DF_Arrangement(MyNumber, DF_FORMATION_DEFENDEE));
	if (!Self.IsForward()){
		for(i = 0; i < num_my; i ++){
			if (motion.MyPlayer_Close2Me(i).Is_goalie) continue;
			if (!motion.MyPlayer_Close2Me(i).IsRoleKnown()) continue;
			if (motion.MyPlayer_Close2Me(i).IsForward()) continue;
			for(j = 0; j < num_opp; j ++){
				if (situation.IsControllerOrFutureController(situation.TheirSide, motion.TheirPlayers_Close2Me[j]) && situation.gamestate == GS_Their_PlaceKick)
					continue;
				AddDF_Arrangement(DF_Arrangement(motion.MyPlayers_Close2Me[i],
					motion.TheirPlayers_Close2Me[j]));
			}
			AddDF_Arrangement(DF_Arrangement(motion.MyPlayers_Close2Me[i],
					DF_FORMATION_DEFENDEE));
		}
	}
	if (num_arrangements <= 0)
		return false;
	return Do_arranging();
}

DF_Arrangement& DF_positioning::GetAssignment(){

	for(int i =0; i < max_nonmutexs; i ++){
		if (Arrangement(optimal_scheme[i]).defender == MyNumber)
			return Arrangement(optimal_scheme[i]);
	}
	//if no arrangement concerning me found, just return the first arrangement
	//there should be a mistake
	Arrangement(0).valid = false;
	return Arrangement(0);
}

float DF_positioning::Getmarkpriority(double threat, double deviation, double dist){
//Export for visual stategy 
	double input[3];
	double output;
	input[0] = threat;
	input[1] =deviation / CP_deviation_max;
	input[2] = dist / CP_deviation_max;
	motion.Mark_Net.SimulateNet(&input[0], &output);
	return float((output - 0.1) * 1.25);
}