df_positioning.cpp

2002年

	input[2] = pos_dist / ClientParam::deviation_max;
	Agent::positioning.Mark_Net.SimulateNet(&input[0], &output);
	return float((output - 0.1) * 1.25);
}
void DF_Arrangement::setdfinfo(){
	fm_pos = formation.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 (!Player::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 (!Player::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;
			return Arrange_DF_Block_for(defender, defendee);
			/*
			 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 (!Player::IsMyPlayer(defender) || !MyPlayer(defender).IsRoleKnown()) return false;
	df_point = formation.GetDefensivePoint(MyPlayer(defender).attackness, MyPlayer(defender).leftness, situation.NextControlBallPos());
	df_point = adjusted_defensivepoint(df_point, defender);
	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){
	getblockposition(defender, defendee, df_point);
	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;
}


Vector DF_Arrangement::adjusted_defensivepoint(Vector defensive_point, UNum defender){
	if (!Player::IsMyPlayer(defender) || !MyPlayer(defender).IsRoleKnown())
		return defensive_point;
	if (MyPlayer(defender).IsBack()){
		float adjustment = float(Min(1.5, fabs(defensive_point.y)/2));
		if (defensive_point.y > 0){
			defensive_point.y -= adjustment;
		}
		else{
			defensive_point.y += adjustment;
		}
	}
	return defensive_point;
}

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
				/*&& this ->df_type == arrangement.df_type*/);
}
/***********	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::ResetPressPriority(){
	int i;
	for(i=0; i< num_arrangements -1;i++){
		if (arrangements[i].df_type == DF_Press){
			arrangements[i].resetpress();
		}
	}
	
}

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(){
	int i;
	for(i = 0; i < num_arrangements - 1; i ++){
		int j;
		for(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();
	/* criver  if the first action with maximum priority is block,
	   increase its priority to enforce the execution of this block action
	   this is a patch.
	*/
	if (num_arrangements > 0){
		if (Arrangement(0).df_type == DF_Block){
			Arrangement(0).priority *= 1.1f;
		}
	}

	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 formation 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  = FieldInfo.Num_MyVisiblePlayers();
	num_opp = FieldInfo.Num_TheirVisiblePlayers();
	if (!Self.IsForward()){
		for(j = 0; j < num_opp; j ++){
			/*if (Self.IsForward() && !situation.IsControllerOrFutureController(FieldInfo.TheirPlayers_Close2Me[j]))
				continue;*/
			if (situation.IsControllerOrFutureController(situation.TheirSide,FieldInfo.TheirPlayers_Close2Me[j]) && situation.gamestate == GS_Their_SetPlay)
					continue;
			AddDF_Arrangement(DF_Arrangement(Agent::MyNumber,
				FieldInfo.TheirPlayers_Close2Me[j]));
		}
	}

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

	bool return_value = Do_arranging();

	return return_value;
}

DF_Arrangement& DF_positioning::GetAssignment(){

	int i;
	for(i =0; i < max_nonmutexs; i ++){
		if (Arrangement(optimal_scheme[i]).defender == Agent::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){
	double input[3];
	double output;
	input[0] = threat;
	input[1] =deviation / ClientParam::deviation_max;
	input[2] = dist / ClientParam::deviation_max;
	Agent::positioning.Mark_Net.SimulateNet(&input[0], &output);
	return float((output - 0.1) * 1.25);
}

void DF_Arrangement::resetpress(){
	priority = getblockpriority();
}

/*  DEBUG  */
const int debug_defenseaction_start_cycle = 1680;
const int debug_defenseaction_end_cycle = 1800;
bool Is_defenseaction_file_opened = false;
FILE * fp_defenseaction_file = NULL;

void DF_positioning::printout_defenseactions(){
	char filename[50];

	if (!Is_defenseaction_file_opened && situation.CurrentTime >= debug_defenseaction_start_cycle
		&& situation.CurrentTime <= debug_defenseaction_end_cycle){
		sprintf(filename, "DefenseActionpool_%d", Agent::MyNumber);
		fp_defenseaction_file = fopen(filename, "w");
		if (fp_defenseaction_file != NULL){
			Is_defenseaction_file_opened = true;
			fprintf(fp_defenseaction_file, "Defender %d\n", Agent::MyNumber);
		}
		else{
			return;
		}
	}
	
	if (situation.CurrentTime > debug_defenseaction_end_cycle && Is_defenseaction_file_opened){
		Is_defenseaction_file_opened = false;
		fclose(fp_defenseaction_file);
		fp_defenseaction_file = NULL;
	}

	if (fp_defenseaction_file == NULL)
		return;

	
	fprintf(fp_defenseaction_file, "----------------------------------------------\n");
	fprintf(fp_defenseaction_file, "Cycle %d at (%.2f %.2f) facing %.2f\n", 
		situation.CurrentTime, Self.pos.x, Self.pos.y, Self.bodyfacing);

	int i;
	for(i=0; i<num_arrangements; i++){
		/* here I am trying to achieve a good alignment of printouts*/
		if (i < 10){
			fprintf(fp_defenseaction_file, "0%d: ", i);
		}
		else{
			fprintf(fp_defenseaction_file, "%d: ", i);
		}

		fprintf(fp_defenseaction_file, "defender %d ", Arrangement(i).defender);
		switch(Arrangement(i).df_type){
		case DF_Formation : fprintf(fp_defenseaction_file, "dftype %s ", "formation   ");break;
		case DF_Mark : fprintf(fp_defenseaction_file, "dftype %s ", "mark ");break;
		case DF_Block : fprintf(fp_defenseaction_file, "dftype %s ", "block");break;
		default: fprintf(fp_defenseaction_file, "bug?");
		}
	
		fprintf(fp_defenseaction_file, "priority %.4f dfpoint (%2.2f,%2.2f) ", Arrangement(i).priority, Arrangement(i).df_point.x,
			Arrangement(i).df_point.y);

		if (Arrangement(i).df_type != DF_Formation){
			fprintf(fp_defenseaction_file, "against %2d", Arrangement(i).defendee-11);
		}
		fprintf(fp_defenseaction_file, "\n");
	}

	fprintf(fp_defenseaction_file, "Optimal Scheme: ");
	for(i = 0; i < max_nonmutexs; i ++){
		fprintf(fp_defenseaction_file, "%d ", optimal_scheme[i]);
	}
	fprintf(fp_defenseaction_file, "\n");
}

/* END OF DEBUG  */