field.cpp

2002年

// field.cpp: implementation of the fields class.
//
//////////////////////////////////////////////////////////////////////

#include "field.h"
#include "geometry.h"
#include "bpn.h"
#include "serverparam.h"
#include "clientparam.h"
#include "worldmodel.h"
#include "strategy.h"
#include "skill.h"
#include "agent.h"
#include "log.h"
/******************      Field  ***************************/
Field::Field(){
}

void Field::Initialize(){
	DirectionDanger::Initialize();
	
	shootablearea = Rect(ServerParam::semi_pitch_length, ServerParam::semi_pitch_length - ClientParam::max_shoot_distance,
		-ServerParam::semi_pitch_width, ServerParam::semi_pitch_width);


	theirgoalie = -1;
	if(Self.Is_goalie)
		mygoalie = Agent::MyNumber;
	else if(FieldParam::FP_goalie_number == Agent::MyNumber)
		mygoalie = -1;
	else
		mygoalie = FieldParam::FP_goalie_number;
}

bool Field::IsInvalidZone(const Vector& Pos){
	switch (situation.playmode){
	case PM_My_Kick_Off:
		return (Pos.x>0);
		break;
	case PM_Their_Kick_Off:
		return (Pos.x>0 || ball.pos_valid() && Pos.dist(ball.pos)<ServerParam::free_kick_buffer);
		break;
	case PM_Their_Goal_Kick :
			return PitchInfo.their_penaltyarea.IsWithin(Pos);
			break;
	case PM_Their_Kick_In :
	case PM_Their_Corner_Kick :
	case PM_Their_Free_Kick :
	case PM_Their_Offside_Kick :
		return (Pos.dist(ball.pos)<ServerParam::free_kick_buffer);
		break;
	default :
		return false;
		break;
	}
}

float Field::GetOffsideLine(){
	if(offsideline.IsDataKnown(situation.CurrentTime))	
		return offsideline.Data(situation.CurrentTime);
	
	float offsidex = 0;
	UNum offsidep = -1;
	
	int oppgoalie = IsValidtheirgoalie() ? theirgoalie  :  1;
	int i;
	for(i = 1; i <= SP_team_size; i ++){
		if(i == oppgoalie) continue;
		if(TheirPlayer(i).IsValidObject() || TheirPlayer(i).pos_valid()){
			if(TheirPlayer(i).pos.x > offsidex){
				offsidex = TheirPlayer(i).pos.x;
				offsidep = i;
			}
		}
	}
	
	float ballposx = ball.pos.x;
	if(situation.BallFree && ball.pos_valid() && ball.IsValidObject())
		ballposx = Max(ballposx, situation.NextControlBallPos().x);
	if (situation.gamestate==GS_Their_SetPlay) 
		offsideline.Setdata(offsidex, situation.CurrentTime);
	    else offsideline.Setdata(Max(offsidex, ballposx), situation.CurrentTime);
	if(offsidep > 0) Behindestopp.Setdata(offsidep, situation.CurrentTime);
	
	return offsideline.Data(situation.CurrentTime);
}

bool Field::IsOffside(){
	return bool(Self.pos.x > (GetOffsideLine() - 1.0f));
}

bool Field::Maybeoffside(){
	if(IsOffside()) return true;

	if(!Susoffsideopp.IsDataKnown(situation.CurrentTime)){
		Susoffsideopp.Setdata(GuessOffside(), situation.CurrentTime);
	}

	return bool(Susoffsideopp.Data(situation.CurrentTime) > 0);
}

UNum Field::GuessOffside(){
	if(Self.pos.x <= 0 || Self.pos.x < ball.pos.x) return -1;

	UNum susopp = -1;
	Player* p;
	if(Behindestopp.IsDataKnown(situation.CurrentTime)){ 
		susopp = Behindestopp.Data(situation.CurrentTime);
		p = &TheirPlayer(susopp);
		if(p->Min_posx() > Self.pos.x){
			return -1;
		}else if(p->Max_posx() <= Self.pos.x){
			//he is sure in behind me
			susopp = -1;
		}
	}

	UNum goalieno = IsValidtheirgoalie() ? theirgoalie : 1;
	goalieno += SP_team_size;
	int i;
	for(i = 0; i < Num_TheirVisiblePlayers(); i++){
		p = &TheirPlayer_InFront(i);
		if(p->InsideNO == goalieno) continue;

		if(p->pos.x < Self.pos.x - 10.0f){
			break;
		}

		//I'm sure of not offside
		if(p->Min_posx() > Self.pos.x) 
			return -1;

		//this opp is sure to be in the behind of me, it's valueless
		if(p->Max_posx() <= Self.pos.x)
			continue;
		
		if(susopp < 0) susopp = TheirPlayers_InFront[i];
	}
	if(susopp < 0){
		//strange thing, some unvisible opp backfielder
		GetOffsideLine();	//find the unvisible backfields
		if(Behindestopp.IsDataKnown(situation.CurrentTime)){ 
			susopp = Behindestopp.Data(situation.CurrentTime);
		}
	}
	return susopp;
}

float Field::GetOffensiveSensitivity(const Vector& pos){
	sensitivity_input[0] = pos.x / 52.5;
	sensitivity_input[1] = fabs(pos.y) / 35;
	OffSensitivityNet.SimulateNet(&sensitivity_input[0], &sensitivity_output);
	return (float)(0.5f + 0.5f * sensitivity_output * 1.111f);
}

float Field::GetDefensiveSensitivity(const Vector& pos){
	sensitivity_input[0] = pos.x / 52.5;
	sensitivity_input[1] = fabs(pos.y) / 34;
	DF_SensitivityNet.SimulateNet(&sensitivity_input[0], &sensitivity_output);
	return float((sensitivity_output - 0.1) * 1.25);
}


int Field::NumOpponentsInCone(AngleDeg direction, float distance, AngleDeg angle_range){
	int num = Num_TheirVisiblePlayers();
	int count = 0;
	int i;
	for(i = 0; i < num; i ++){
		if (TheirPlayer_Close2Me(i).distance > distance)
			break;
		else{
			if (fabs(NormalizeAngle(TheirPlayer_Close2Me(i).global_angle - direction)) < angle_range / 2.0f){
				count ++;
			}
		}
	}
	return count;
}

int Field::NumOpponentsInCone(Vector pos, AngleDeg direction, float distance, AngleDeg angle_range){
	int num = Num_TheirVisiblePlayers();
	int count = 0;
	Vector gap;
	int i;
	for(i = 0; i < num; i ++){
		gap = TheirPlayer_Close2Me(i).pos - pos;
		if (gap.mod2() < Sqr(distance) && fabs(gap.Angle() - direction) <= angle_range /2)
				count ++;
	}
	return count;
}

int Field::NumTeammatesInCone(AngleDeg direction, float distance, AngleDeg angle_range){
	int num = Num_MyVisiblePlayers();
	int count = 0;
	int i;
	for(i = 0; i < num; i ++){
		if (MyPlayer_Close2Me(i).distance > distance)
			break;
		else{
			if (fabs(NormalizeAngle(MyPlayer_Close2Me(i).global_angle - direction)) < angle_range / 2.0f){
				count ++;
			}
		}
	}
	return count;	
}


int Field::NumTeammatesInCone(Vector pos, AngleDeg direction, float distance, AngleDeg angle_range){
	int num = Num_MyVisiblePlayers();
	int count = 0;
	Vector gap;
	int i;
	for(i = 0; i < num; i ++){
		gap = MyPlayer_Close2Me(i).pos - pos;
		if (gap.mod2() < Sqr(distance) && fabs(NormalizeAngle(gap.Angle() - direction)) <= angle_range /2)
			count ++;
	}
	return count;
}

int Field::NumNoneGoalieTeammatesInCone(Vector end1, Vector end2, AngleDeg angle_range){
	Vector polar = end2 - end1;
	return NumNoneGoalieTeammatesInCone(end1, polar.Angle(), polar.mod(), angle_range);
}

int Field::NumNoneGoalieTeammatesInCone(Vector pos, AngleDeg direction, float distance, AngleDeg angle_range){
	int num = Num_MyVisiblePlayers();
	int count = 0;
	Vector gap;
	int i;
	for(i = 0; i < num; i ++){
		if (MyPlayers_Close2Me[i] == FieldParam::FP_goalie_number) continue;
		gap = MyPlayer_Close2Me(i).pos - pos;
		if (gap.mod2() < Sqr(distance) && fabs(NormalizeAngle(gap.Angle() - direction)) <= angle_range /2)
			count ++;
	}
	return count;
}

int Field::NumOpponentsWithin(float distance){
	int num = Num_TheirVisiblePlayers();
	int count = 0;
	int i;
	for(i = 0; i < num; i ++){
		if (TheirPlayer_Close2Me(i).distance > distance)
			break;
		count ++;
	}
	return count;
}

int Field::NumTeammatesWithin(float distance){
	int num = Num_MyVisiblePlayers();
	int count = 0;
	int i;
	for(i = 0; i < num; i ++){
		if (MyPlayer_Close2Me(i).distance > distance)
			break;
		count ++;
	}
	return count;
}

int Field::NumOpponentsWithin(float Dist, AngleDeg angle, float ofDist, AngleDeg ofangle){
	int num = Num_TheirVisiblePlayers();
	int count = 0;
	int i;
	for(i = 0; i < num; i ++){
		if (TheirPlayer_Close2Me(i).distance > ofDist)
			break;
		if (TheirPlayer_Close2Me(i).distance > Dist 
			&& Angle_between(TheirPlayer_Close2Me(i).global_angle, angle, ofangle)){
			count ++;
		}
	}
	return count;
}

int Field::NumTeammatesWithin(float Dist, AngleDeg angle, float ofDist, AngleDeg ofangle){
	int num = Num_MyVisiblePlayers();
	int count = 0;
	int i;
	for(i = 0; i < num; i ++){
		if (MyPlayer_Close2Me(i).distance > ofDist)
			break;
		if (MyPlayer_Close2Me(i).distance > Dist 
			&& Angle_between(MyPlayer_Close2Me(i).global_angle, angle, ofangle)){
			count ++;
		}
	}
	return count;
}

int Field::NumOpponentsWithin(float distance, Vector pos){
	int num = Num_TheirVisiblePlayers();
	int count = 0;
	int i;
	for(i = 0; i < num; i ++){
		if ((TheirPlayer_Close2Me(i).pos - pos).mod2() < Sqr(distance))
			count ++;
	}
	return count;
}

int Field::NumTeammatesWithin(float distance, Vector pos){
	int num = Num_MyVisiblePlayers();
	int count = 0;
	int i;
	for(i = 0; i < num; i ++){
		if ((MyPlayer_Close2Me(i).pos - pos).mod2() < Sqr(distance))
			count ++;
	}
	return count;
}


bool Field::IsBlocked(UNum No){
	if (Player::IsTheirPlayer(No)){
		return IsBlocked(situation.TheirSide, No - SP_team_size);
	}
	else if (Player::IsMyPlayer(No)){