field.cpp

2002年

		return IsBlocked(situation.MySide, No);
	}
	return false;
}

bool Field::IsBlocked(char side, UNum No){ 
	if (situation.TheirSide == side)
	{
		Vector OPos = TheirPlayer(No).pos;
		AngleDeg l_goal_ang = (PitchInfo.l_mygoalpost - OPos).Angle();
		AngleDeg r_goal_ang = (PitchInfo.r_mygoalpost - OPos).Angle();
		AngleDeg m_ang = MidAngle2(l_goal_ang,r_goal_ang);
		return (NumTeammatesInCone(OPos,m_ang,ClientParam::block_dist,AngleDif(l_goal_ang,r_goal_ang)) > 0);
	}
	else{
		if (MyPlayer(No).pos_valid()){
			float angle = (PitchInfo.theirgoal - MyPlayer(No).pos).Angle();
			return bool(NumNoneGoalieTeammatesInCone(MyPlayer(No).pos, angle, ClientParam::block_dist, 120.0f) > 0);
		}
	}
	return false;
}

float Field::FitPosDegree(Vector CurrentPos, Vector TargetPos, float radius){
	if (radius<1.0f) radius=1.0f;
	return (TargetPos.dist(CurrentPos) < radius ? 1 : 
              1/(1+Sqr(TargetPos.dist(CurrentPos)/radius-1.0f) * 4.0f));	
}

 float Field::FitPosDegree(UNum No, Vector TargetPos, float radius){
	return FitPosDegree(MyPlayer(No).pos, TargetPos, radius);
}

float Field::CalcThreat(UNum No){
	//estimate threat of an opponent
	if (!Player::IsTheirPlayer(No)) return 0.0f;
	return TheirPlayer(No).GetDefsensitivity();
}

void Field::SetArounds(){
	int i, j;
	num_my_visible_players = 0;
	num_their_visible_players = 0;
	DoLog(LOG_SEE, "unk my %d", UnknownMyPlayerList.numplayers);
	DoLog(LOG_SEE, "unk their %d", UnknownTheirPlayerList.numplayers);
	DoLog(LOG_SEE, "teamless %d", TeamlessPlayerList.numplayers);
	if(!IsValidtheirgoalie() && TheirPlayer(1).pos_conf<0.1f){
		TheirPlayer(1).pos = Vector(40, 0);
	}
/******   Get visible players list  ********************/
	for(i = 1; i <= SP_team_size; i++){
		if (i != Agent::MyNumber && MyPlayer(i).pos_valid()){
			MyVisiblePlayers[num_my_visible_players++] = i;
			DoLog(LOG_SEE,"My %d(%.2f,%.2f) %.2f",i,MyPlayer(i).pos.x,MyPlayer(i).pos.y, MyPlayer(i).ActiveRadius(situation.CurrentTime) );
		}
		if (TheirPlayer(i).pos_valid() || (TheirPlayer(i).Is_goalie && TheirPlayer(i).IsValidObject()) ){
			TheirVisiblePlayers[num_their_visible_players++] = i + SP_team_size;
			DoLog(LOG_SEE,"Opp %d(%.2f,%.2f) %.2f",i,TheirPlayer(i).pos.x,TheirPlayer(i).pos.y, TheirPlayer(i).ActiveRadius(situation.CurrentTime) );			
		}
	}
	
	for(i = 0; i < UnknownMyPlayerList.numplayers; i ++){
		MyVisiblePlayers[num_my_visible_players++] = 2 * SP_team_size + i +1;
		DoLog(LOG_SEE,"My unk(%.2f,%.2f) %.2f",MyPlayer(2 * SP_team_size + i +1).pos.x,MyPlayer(2 * SP_team_size + i +1).pos.y, 
			MyPlayer(2 * SP_team_size + i +1).ActiveRadius(situation.CurrentTime));
		if (num_my_visible_players >= CP_max_visible_players)
			break;
	}
	for(i = 0; i < UnknownTheirPlayerList.numplayers; i ++){
		TheirVisiblePlayers[num_their_visible_players++] = 4 * SP_team_size + i + 1;
		DoLog(LOG_SEE,"Their unk(%.2f,%.2f)",TheirPlayer(4* SP_team_size + i +1).pos.x,TheirPlayer(4 * SP_team_size + i +1).pos.y,
			TheirPlayer(4* SP_team_size + i +1).ActiveRadius(situation.CurrentTime));
		if (num_their_visible_players >= CP_max_visible_players)
			break;
	}

	for(i = 0; i < TeamlessPlayerList.numplayers; i ++){
		TheirVisiblePlayers[num_their_visible_players++] = 6 * SP_team_size + i + 1;
		DoLog(LOG_SEE,"Their teamless(%.2f,%.2f) %.2f",TheirPlayer(6* SP_team_size + i +1).pos.x,TheirPlayer(6 * SP_team_size + i +1).pos.y,
			TheirPlayer(6* SP_team_size + i +1).ActiveRadius(situation.CurrentTime));
		if (num_their_visible_players >= CP_max_visible_players)
			break;
	}

	for(i = 0; i < num_my_visible_players; i++){
		MyPlayers_Close2Ball[i] = MyPlayers_Close2Me[i] = MyPlayers_InFront[i] = MyVisiblePlayers[i];
	}
	for(i = 0; i < num_my_visible_players - 1; i++){
		for ( j = i + 1; j < num_my_visible_players; j ++){
			if (MyPlayer(MyPlayers_Close2Ball[j]).balldist < MyPlayer(MyPlayers_Close2Ball[i]).balldist){
				Swap(MyPlayers_Close2Ball[i], MyPlayers_Close2Ball[j]);
			}
			if (MyPlayer(MyPlayers_Close2Me[j]).distance < MyPlayer(MyPlayers_Close2Me[i]).distance){
				Swap(MyPlayers_Close2Me[i], MyPlayers_Close2Me[j]);
			}
			if (MyPlayer(MyPlayers_InFront[j]).pos.x > MyPlayer(MyPlayers_InFront[i]).pos.x){
				Swap(MyPlayers_InFront[j], MyPlayers_InFront[i]);
			}
		}
	}
	for(i = 0; i < num_their_visible_players; i++){
		TheirPlayers_Danger[i] = TheirPlayers_Close2Ball[i] = TheirPlayers_Close2Me[i] = TheirPlayers_InFront[i] = TheirVisiblePlayers[i];
	}
	for(i = 0; i < num_their_visible_players - 1; i++){
		for ( j = i + 1; j < num_their_visible_players; j ++){
			if (TheirPlayer(TheirPlayers_Close2Ball[j]).balldist < TheirPlayer(TheirPlayers_Close2Ball[i]).balldist){
				Swap(TheirPlayers_Close2Ball[i], TheirPlayers_Close2Ball[j]);
			}
			if (TheirPlayer(TheirPlayers_Close2Me[j]).distance < TheirPlayer(TheirPlayers_Close2Me[i]).distance){
				Swap(TheirPlayers_Close2Me[i], TheirPlayers_Close2Me[j]);
			}
			if (TheirPlayer(TheirPlayers_InFront[j]).pos.x > TheirPlayer(TheirPlayers_InFront[i]).pos.x){
				Swap(TheirPlayers_InFront[j], TheirPlayers_InFront[i]);
			}
			if (TheirPlayer(TheirPlayers_Danger[j]).GetDefsensitivity()
				> TheirPlayer(TheirPlayers_Danger[i]).GetDefsensitivity())
				Swap(TheirPlayers_Danger[i],TheirPlayers_Danger[j]);
		}
	}
	for(i = 0; i < num_my_visible_players; i ++)
		MyPlayers_InBehind[i] = MyPlayers_InFront[num_my_visible_players - 1 - i];


	for(i = 0; i < num_their_visible_players; i++)
		TheirPlayers_InBehind[i] = TheirPlayers_InFront[num_their_visible_players - 1 - i];

	num_visible_players = num_my_visible_players + num_their_visible_players;
	i = 0; j = 0; int num_players_close2me = 0;
	while(i < num_my_visible_players || j < num_their_visible_players){
		if (i >= num_my_visible_players){
			while(j < num_their_visible_players){
				Players_Close2Me[num_players_close2me++] = TheirPlayers_Close2Me[j++];
			}
		}
		else if(j >= num_their_visible_players){
			while(i < num_my_visible_players){
				Players_Close2Me[num_players_close2me++] = MyPlayers_Close2Me[i++];
			}
		}
		else{
			if (MyPlayer_Close2Me(i).distance < TheirPlayer_Close2Me(j).distance)
				Players_Close2Me[num_players_close2me++] = MyPlayers_Close2Me[i++];
			else
				Players_Close2Me[num_players_close2me++] = TheirPlayers_Close2Me[j++];
		}
	}

	i = 0; j = 0; int num_players_close2ball = 0;
	while(i < num_my_visible_players || j < num_their_visible_players){
		if (i >= num_my_visible_players){
			while(j < num_their_visible_players){
				Players_Close2Ball[num_players_close2ball++] = TheirPlayers_Close2Ball[j++];
			}
		}
		else if(j >= num_their_visible_players){
			while(i < num_my_visible_players){
				Players_Close2Ball[num_players_close2ball++] = MyPlayers_Close2Ball[i++];
			}
		}
		else{
			if (MyPlayer_Close2Ball(i).balldist < TheirPlayer_Close2Ball(j).balldist)
				Players_Close2Ball[num_players_close2ball++] = MyPlayers_Close2Ball[i++];
			else
				Players_Close2Ball[num_players_close2ball++] = TheirPlayers_Close2Ball[j++];
		}
	}
	SetBallInf();
}

void Field::SetBallInf(){
	UNum closestp = -1;
	float min_dist = 100.0f;
	if(num_my_visible_players > 0){
		if(MyPlayers_Close2Ball[0] == Agent::MyNumber && num_my_visible_players > 1){
			closestp = MyPlayers_Close2Ball[1];
		}
		else{
			closestp = MyPlayers_Close2Ball[0] ;
		}
		min_dist = MyPlayer(closestp).balldist;
		ball.Setball_CPlayer(closestp,MyPlayer(closestp).pos,situation.CurrentTime);
	}
	if(num_their_visible_players > 0){
		if(TheirPlayer(TheirPlayers_Close2Ball[0]).balldist < min_dist){
			closestp = TheirPlayers_Close2Ball[0] ;
			ball.Setball_CPlayer(closestp,TheirPlayer(closestp).pos,situation.CurrentTime);
		}
	}	
}

Player& Field::MyPlayer_Close2Me(int idx){
//	DoLog(LOG_SEE,"MyPlayer_Close2Me(%d) %d",idx,MyPlayers_Close2Me[idx]);
	return MyPlayer(MyPlayers_Close2Me[idx]);
}

Player& Field::TheirPlayer_Close2Me(int idx){
//	DoLog(LOG_SEE,"TheirPlayer_Close2Me(%d) %d",idx,TheirPlayers_Close2Me[idx]);
	return TheirPlayer(TheirPlayers_Close2Me[idx]);
}

Player& Field::GetPlayer_Close2Me(int idx){
	return GetPlayer(Players_Close2Me[idx]);
}

Player& Field::MyPlayer_Close2Ball(int idx){
	return MyPlayer(MyPlayers_Close2Ball[idx]);
}

Player& Field::TheirPlayer_Close2Ball(int idx){
	return TheirPlayer(TheirPlayers_Close2Ball[idx]);
}

Player& Field::GetPlayer_Close2Ball(int idx){
	return GetPlayer(Players_Close2Ball[idx]);
}

Player& Field::MyPlayer_InFront(int idx){
	return MyPlayer(MyPlayers_InFront[idx]);
}

Player& Field::MyPlayer_InBehind(int idx){
	return MyPlayer(MyPlayers_InBehind[idx]);
}

Player& Field::TheirPlayer_InFront(int idx){
	return TheirPlayer(TheirPlayers_InFront[idx]);
}

Player& Field::TheirPlayer_InBehind(int idx){
	return TheirPlayer(TheirPlayers_InBehind[idx]);
}

Player& Field::MyPlayer_CtrlOfBall(int idx){
	return MyPlayer(Skill::interception.MyPlayers_Interception[idx]);
}

Player& Field::TheirPlayer_CtrlOfBall(int idx){
	return TheirPlayer(Skill::interception.TheirPlayers_Interception[idx]);
}

int Field::TheirPlayerNum_CtrlOfBall(int idx){
	return Skill::interception.TheirPlayers_Interception[idx];
}

int Field::MyPlayerNum_CtrlOfBall(int idx){
	return Skill::interception.MyPlayers_Interception[idx];
}

void DirectionDanger::Initialize(){	
	int i;
	for(i = 0; i < ClientParam::num_divisions; i ++){
		dir_danger[i]=0;
	}
}

float DirectionDanger::DirDanger(AngleDeg dir){
	return dir_danger[int(NormalizeAngle(dir, 0.0f) / ClientParam::division)];
}

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

float DirectionDanger::DirDanger(AngleDeg dir, float delta){
	int i0, i1;
	i0 = int(NormalizeAngle(dir - delta, 0) / ClientParam::division);
	i1 = int(NormalizeAngle(dir + delta, 0.0f) / ClientParam::division);
	float max_danger = 0;
	if(i0 <= i1){
		for(; i0<=i1; i0++){
			max_danger = Max(max_danger, dir_danger[i0]);
		}
	}else{
		for(; i0<ClientParam::num_divisions; i0++){
			max_danger = Max(max_danger, dir_danger[i0]);
		}
		for(i0=0; i0<=i1; i0++){
			max_danger = Max(max_danger, dir_danger[i0]);
		}
	}
	return max_danger;
}

void DirectionDanger::Update_dirdanger(Time time){
	int i,i0,i1;
	RingSector * ps;
	NoiseData *sector; 

	for(i = 0; i < ClientParam::num_divisions; i ++){
		dir_danger[i]=0;
	}
	Ghosts.Reset();
	Player* p;
	for (i=1; i<=SP_team_size; i++){
		p = &TheirPlayer(i);
		if (p->pos_valid()) continue;
		if (!p->IsValidObject()) continue; 
		ps = &(p->domain.Data(situation.CurrentTime));
		if(!ps->IsValid()) continue;
		if(ps->radius.mean > ServerParam::team_far_length) continue;
		Ghosts.Add(&TheirPlayer(i));
		int j;
		for(j=0; j<ps->angles.Num_datas(); j++){
			sector = & ps->angles.Data(j);
			i0 = int(NormalizeAngle(sector->mean - sector->delta, 0) / ClientParam::division);
			i1 = int(NormalizeAngle(sector->mean + sector->delta, 0.0f) / ClientParam::division);
			if(i0 <= i1){
				for (; i0 <= i1; i0++){
					dir_danger[i0] ++;
				}
			}else{
				for(; i0<ClientParam::num_divisions; i0++){
					dir_danger[i0] ++;
				}
				for(i0=0; i0<=i1; i0++){
					dir_danger[i0] ++;
				}
			}
		}
	}	
}