dribble.cpp

RoboCup 2D 仿真组老牌强队Mersad 2005的完整源代码

		{
			if (worldModel->getQuarterPlayer(j).isAlive())
			{
				playerPoint = worldModel->getQuarterPlayer(j).getPos();
	
				float playerDist =  hypot(dribblePoints[i].x - playerPoint.x, 
						dribblePoints[i].y - playerPoint.y);
	
				if (playerDist < senceArea)
				{
					dribbleWeights[i] -= senceArea - playerDist;	
					opponentInSence = 1;
 				}
			}	
		}
	}
}

int Dribble::bestDribblePoint()
{
	float senceArea = 2; // Sassan (1.8)
	opponentInSence = 0;
	setOpponentInWeight(senceArea);
	if (opponentInSence)
	{
		setDribbleArgumentsByOpponent();
		setOpponentInWeight(senceArea);
	}
	
	int bestDribbleCount = 0;
	float goodWeight = .09;
	
	
	for (int i = 0; i < 12; i++)
	{
#ifdef DRIBBLE_LOGLEVEL1
		LOG << "dribbleWeight[" << i << "]" << dribbleWeights[i] << endl;	
#endif

		if (dribbleWeights[i] > dribbleWeights[bestDribbleCount] || 
			(virtualWeight[i] > virtualWeight[bestDribbleCount] && 
			dribbleWeights[i] + goodWeight > dribbleWeights[bestDribbleCount]))	
			bestDribbleCount = i;
	}
		
	if (bestDribbleCount == 0 && dribbleWeights[0] == dribbleWeights[1])
	{
		Command *dashCommand = new DashCommand(AT_DRIBBLE, 100);
		Ball ballByDash, ballNoDash;
		ballByDash = worldModel->getBall();
		ballNoDash = worldModel->getBall();

		Body bodyByDash, bodyNoDash;
		bodyByDash  = worldModel->getBody();
		bodyNoDash = worldModel->getBody();
	
		bodyNoDash.simulateByDynamics();
		bodyByDash.simulateByAction(dashCommand);
		bodyByDash.simulateByDynamics();
		ballNoDash.simulateByDynamics(bodyNoDash);
		ballByDash.simulateByDynamics(bodyByDash);
		if (ballNoDash.getBodyVec().getDirection() <= 0)
			bestDribbleCount = 1;
		delete dashCommand;
	}
	return bestDribbleCount;			
}


void Dribble::setAngleWeight(int targetCount)
{
	float angleWeight = 0;
	float deltaAngle = targetAngles[targetCount] - targetAngles[0];
	deltaAngle = Degree::normalizeAngle(deltaAngle);

	Vector tempVector;
	tempVector.setAsPolar(cautionLength, deltaAngle);

	angleWeight += ((180 - fabs(deltaAngle)) / 30.00) * .15;

	float deltaBodyAngle = targetAngles[targetCount] - 
				worldModel->getBody().getBodyDir();
	deltaBodyAngle = Degree::normalizeAngle(deltaBodyAngle);
	
	 
	//KOMAK in if bayad az lahaze algorithmi avaz shavad.
	if (isOpponent && fabs(deltaBodyAngle) < 20 && targetAngles[targetCount]) 
	{
/*	
	float myModel = fabs(targetWeights[targetCount]);
	if (myModel > 80)
		myModel = 80;
	if (myModel < 3)
		myModel  = 3;
*/		
		angleWeight += .04;
	}
	targetWeights[targetCount] += angleWeight * angleWeightRate;
}

void Dribble::setCraudWeight(int targetCount)
{
	float beginAngle = targetAngles[targetCount] - 90;
	beginAngle = Degree::normalizeAngle(beginAngle);
	Vector tempVector;
	
	float currentAngle;
	float craudWeight = 0;
	float playerDist;
	float negWeight = 0;
	float xRate = .25;
	float localNegWeight;
	
	for (int j = 0; j < FULL_PLAYERS_NUM; j++)
		if (worldModel->getFullPlayer(TID_OPPONENT, j).isValid())
		{
			currentAngle = worldModel->getFullPlayer(TID_OPPONENT, j).getAbsVec().getDirection() - beginAngle;	
			currentAngle = Degree::normalizeAngle(currentAngle);

			playerDist = worldModel->getFullPlayer(TID_OPPONENT, j).getBodyVec().getMagnitude();			
			tempVector.setAsPolar(playerDist, currentAngle);

			if (playerDist < cautionLength * 1.2)
				isOpponent = 1;

			if (tempVector.getY() <= cautionLength && tempVector.getY() > 0 && 
					fabs(tempVector.getX()) <= (cautionLength * xRate))
			{
				localNegWeight = -(tempVector.getY() - fabs(tempVector.getX()));
				localNegWeight *= (fabs(tempVector.getX()) / cautionLength) / xRate;

				if (playerDist < 5)
				{
					float rate = 5 - playerDist;
					if (rate < 1.5)
						rate = 1.5;
	
					localNegWeight *= rate;
				}

				if (localNegWeight > 0)
					localNegWeight = 0;

				if (localNegWeight < negWeight)
					negWeight = localNegWeight;
			}
		}	


	for (int j = 0; j < QUARTER_PLAYERS_NUM; j++)
		if (worldModel->getQuarterPlayer(j).isAlive())
		{
			currentAngle = worldModel->getQuarterPlayer(j).getAbsVec().getDirection() - beginAngle;	
			currentAngle = Degree::normalizeAngle(currentAngle);
	
			playerDist = worldModel->getQuarterPlayer(j).getBodyVec().getMagnitude();			
			tempVector.setAsPolar(playerDist, currentAngle);
	
			if (playerDist < cautionLength * 1.2)
				isOpponent = 1;
	
			if (tempVector.getY() <= cautionLength && tempVector.getY() > 0 && 
					fabs(tempVector.getX()) <= (cautionLength * xRate))
			{
				localNegWeight = -(tempVector.getY() - fabs(tempVector.getX()));
				localNegWeight *= (fabs(tempVector.getX()) / cautionLength) / xRate;

				if (playerDist < 5)
				{
					float rate = 5 - playerDist;
					if (rate < 1.5)
						rate = 1.5;

					localNegWeight *= rate;
				}

				if (localNegWeight > 0)
					localNegWeight = 0;

				if (localNegWeight < negWeight)
					negWeight = localNegWeight;
			}
		}
		
	craudWeight = negWeight;
	targetWeights[targetCount] += craudWeight * craudWeightRate;	
}

void Dribble::setTargetWeight(int targetCount)
{
	setCraudWeight(targetCount);
	setAngleWeight(targetCount);
//	LOG << "TotalWeight : " << targetAngles[targetCount] << " " << 
//		targetWeights[targetCount] << endl; 
}


void Dribble::setDribbleTarget(int dribbleCount)
{
	Vector tempVector;
	
	tempVector.setByPoints(Point(worldModel->getBody().getPos().getX(), 
			worldModel->getBody().getPos().getY()), dribbleTarget);
	
	float beginAngle = tempVector.getDirection();   
	
	for (int i = 0; i < targetNums; i++) 
	{
		targetAngles[i] = beginAngle + (i * 10); 	
		targetAngles[i] = Degree::normalizeAngle(targetAngles[i]);
		setTargetWeight(i);
	}

	if (worldModel->getBall().getPos().getY() >= 31)
		for (int i = 0; i < targetNums; i++)
			if (targetAngles[i] > 0 || (worldModel->getBall().getPos().getY() >= 
				32 && targetAngles[i] >= 0))
				targetWeights[i] -= 1000;

	if (worldModel->getBall().getPos().getY() <= -31)
		for (int i = 0; i < targetNums; i++)
			if (targetAngles[i] < 0 || (worldModel->getBall().getPos().getY() <= 
				-32 && targetAngles[i] <= 0))
				targetWeights[i] -= 1000;
	
	if (worldModel->getBall().getPos().getX() >= 50)
		for (int i = 0; i < targetNums; i++)
			if (fabs(targetAngles[i]) < 90 || 
				(worldModel->getBall().getPos().getX() >= 51 && 
				fabs(targetAngles[i]) <= 90))
				targetWeights[i] -= 1000;

	int bestDribbleTarget = 0;

	for (int i = 0; i < targetNums; i++)
		if (targetWeights[i] > targetWeights[bestDribbleTarget])
			bestDribbleTarget = i;

	Vector lastVector;
	lastVector.setAsPolar(10, targetAngles[bestDribbleTarget]);

	dribbleTarget.x = worldModel->getBody().getPos().getX() + lastVector.getX();
	dribbleTarget.y = worldModel->getBody().getPos().getY() + lastVector.getY();

#ifdef DRIBBLE_LOGLEVEL1
	LOG << "MainDribbletarget : " << dribbleTarget << endl;
#endif
}

bool Dribble::checkDribbleTarget(int dribbleCount)
{
	float kickableArea;
	float deltaAngle;
	float dribbleAngle;
	float maxDeltaAngle;
	Vector targetVector;
	Vector dribbleVector;
	Point ballPoint;
	Point dribblePoint;

	setDribbleTarget(dribbleCount);

	kickableArea = worldModel->getBody().getSize() +
			 worldModel->getBody().getKickableMargin() +
			 worldModel->getBall().getSize();
	
	targetVector.setByPoints(Point(worldModel->getBody().getPos().getX(), 
			worldModel->getBody().getPos().getY()), dribbleTarget);

	deltaAngle = targetVector.getDirection() - 
			worldModel->getBody().getBodyDir();
	deltaAngle = Degree::normalizeAngle(deltaAngle);
	
	ballPoint.x = worldModel->getBall().getPos().getX();
	ballPoint.y = worldModel->getBall().getPos().getY();
	
	maxDeltaAngle = 30;
	if (worldModel->getBody().getPos().getY() > 31 && 
		worldModel->getBody().getBodyDir() > 0 && deltaAngle < 0)  
		maxDeltaAngle = 0;				   
	
	if (worldModel->getBody().getPos().getY() < -31 && 
		worldModel->getBody().getBodyDir() < 0 && deltaAngle > 0) 
		maxDeltaAngle = 0;				   
	
	if (worldModel->getBody().getPos().getX() > 50 && 
		fabs(worldModel->getBody().getBodyDir()) < 90) 
		maxDeltaAngle = 0;				   

	dribbleAngle = worldModel->getBody().getBodyDir();
	
	dribbleAngle += angle[dribbleCount];
	dribbleAngle = Degree::normalizeAngle(dribbleAngle);	

	dribbleVector.setAsPolar(kickableArea - noise1[dribbleCount] - .2, dribbleAngle);
	
	dribblePoint.x = checkTargetBody.getPos().getX() + dribbleVector.getX();
	dribblePoint.y = checkTargetBody.getPos().getY() + dribbleVector.getY();
	
	float extraNoise = 0;
	
	if (worldModel->getBall().getVel().getMagnitude() > .5)
		extraNoise = .1;
		
	if (fabs(worldModel->getBall().getPos().getX()) > 49.5 ||
		fabs(worldModel->getBall().getPos().getY()) > 32)
		extraNoise += .25;	

	if (fabs(deltaAngle) > maxDeltaAngle)
	{
		if (checkTargetBall.getBodyVec().getMagnitude() + 
			kickableNoise[dribbleCount] + extraNoise >= kickableArea || 
			(opponentInSence && hypot(dribblePoint.x - ballPoint.x, 
			dribblePoint.y - ballPoint.y) > 
			max((maxDist[dribbleCount] * kickableArea), (float)(.2))))
		{
			dribbleCommand = KickToPointCycles(AT_DRIBBLE, dribblePoint, 1, 
				worldModel->getBall(), worldModel->getBody()).getCommand();  
			
#ifdef DRIBBLE_LOGLEVEL1
			LOG << "dribbleBUG 1 : dribblePoint : " << dribblePoint << endl;
#endif
		}
		else
			dribbleCommand = TurnAngle(AT_DRIBBLE, deltaAngle, 
				worldModel->getBody()).getCommand();
		return 0;
	}
	return 1;
}


float  Dribble::getInlineDribbleWeight(int dribbleCount, float senceArea)
{
	float inlineDribbleWeight = 0;
	Point playerPoint;
	for (int j = 0; j < FULL_PLAYERS_NUM; j++)
	{
/*	BY AHMAD    if (worldModel->getFullPlayer(TID_TEAMMATE, j).isValid() &&
				!worldModel->getFullPlayer(TID_TEAMMATE, j).isBody())
			{
				playerPoint = worldModel->getFullPlayer(TID_TEAMMATE, j).getPos();
				
				float playerDist =  hypot(dribblePoints[i].x - playerPoint.x, 
						dribblePoints[i].y - playerPoint.y);
	
				if (playerDist < senceArea)
				{
					dribbleWeights[i] -= senceArea - playerDist;	
					opponentInSence = 1;
 				}
			}	*/
	
		if (worldModel->getFullPlayer(TID_OPPONENT, j).isValid())
		{
			playerPoint = worldModel->getFullPlayer(TID_OPPONENT, j).getPos();
			
			float playerDist =  hypot(dribblePoints[dribbleCount].x - playerPoint.x, 
					dribblePoints[dribbleCount].y - playerPoint.y);
			if (playerDist < senceArea)
			{
				inlineDribbleWeight -= senceArea - playerDist;	
				opponentInSence = 1;
 			}
		}	
	}
	for (int j = 0; j < HALF_PLAYERS_NUM; j++)
	{
/*	BY AHMAD   if (worldModel->getHalfPlayer(TID_TEAMMATE, j).isValid())
			{
				playerPoint = worldModel->getHalfPlayer(TID_TEAMMATE, j).getPos();
				
				float playerDist =  hypot(dribblePoints[i].x - playerPoint.x, 
						dribblePoints[i].y - playerPoint.y);
	
				if (playerDist < senceArea)
				{
					dribbleWeights[i] -= senceArea - playerDist;	
					opponentInSence = 1;
 				}
			}	*/

		if (worldModel->getHalfPlayer(TID_OPPONENT, j).isValid())
		{
			playerPoint = worldModel->getHalfPlayer(TID_OPPONENT, j).getPos();

			float playerDist =  hypot(dribblePoints[dribbleCount].x - 
				playerPoint.x, dribblePoints[dribbleCount].y - playerPoint.y);

			if (playerDist < senceArea)
				inlineDribbleWeight -= senceArea - playerDist;	
		}	
	}

	for (int j = 0; j < QUARTER_PLAYERS_NUM; j++)
	{
		if (worldModel->getQuarterPlayer(j).isAlive())
		{
			playerPoint = worldModel->getQuarterPlayer(j).getPos();
	
			float playerDist =  hypot(dribblePoints[dribbleCount].x - playerPoint.x, 
					dribblePoints[dribbleCount].y - playerPoint.y);
	
			if (playerDist < senceArea)
				inlineDribbleWeight -= senceArea - playerDist;	
		}	
	}
	return inlineDribbleWeight;
}

bool Dribble::ballInOppKickable()
{
	Point playerPoint;
	for (int j = 0; j < FULL_PLAYERS_NUM; j++)
		if (worldModel->getFullPlayer(TID_OPPONENT, j).isValid())
		{
			playerPoint = worldModel->getFullPlayer(TID_OPPONENT, j).getPos();

			float playerDist =  hypot(checkTargetBall.getPos().getX() - playerPoint.x, 
				checkTargetBall.getPos().getY() - playerPoint.y);

			if (playerDist <= 1.2)
				return 1;
		}	
	
	for (int j = 0; j < QUARTER_PLAYERS_NUM; j++)
		if (worldModel->getQuarterPlayer(j).isAlive())
		{
			playerPoint = worldModel->getQuarterPlayer(j).getPos();	

			float playerDist =  hypot(checkTargetBall.getPos().getX() - playerPoint.x, 
					checkTargetBall.getPos().getY() - playerPoint.y);	

			if (playerDist <= 1.2)
				return 1;
		}

	return 0;
}


float Dribble::getValue(const Library &library)
{
	LOG << "Dribble::getValue" << endl;

	int dribbleCount;
	int localCycleNums;
	float kickableArea;
	float localDashPower;
	Point dribblePoint;
	Point ballPoint;
	Vector dribbleVector;
	Ball ballByDash, ballNoDash, nextBall;
	Body bodyByDash, bodyNoDash, nextBody;
		
	setDribblePoints();
	dribbleCount = bestDribblePoint();
	kickableArea = worldModel->getBody().getSize() +
			 worldModel->getBody().getKickableMargin() +
			 worldModel->getBall().getSize();
	
	ballPoint.x = worldModel->getBall().getPos().getX();
	ballPoint.y = worldModel->getBall().getPos().getY();

	float dribbleAngle = worldModel->getBody().getBodyDir();
	
	dribbleAngle += angle[dribbleCount];
	dribbleAngle = Degree::normalizeAngle(dribbleAngle);	

	dribbleVector.setAsPolar(kickableArea - noise1[dribbleCount], dribbleAngle);
	
	ballByDash = worldModel->getBall();
	ballNoDash = worldModel->getBall();
	nextBall = worldModel->getBall();

	bodyByDash  = worldModel->getBody();
	bodyNoDash = worldModel->getBody();
	nextBody = worldModel->getBody();

	localDashPower = dashPower[dribbleCount];
	
	if (worldModel->getBody().getStamina() < 1400)
		localDashPower = worldModel->getBody().getStaminaIncMax();

	Command *dashCommand = new DashCommand(AT_DRIBBLE, localDashPower);
	
	bodyNoDash.simulateByDynamics();
	bodyByDash.simulateByAction(dashCommand);
	bodyByDash.simulateByDynamics();
	
	ballNoDash.simulateByDynamics(bodyNoDash);
	ballByDash.simulateByDynamics(bodyByDash);
  
  	float ballDistByDash, ballDistNoDash;
	  
	ballDistByDash = hypot(ballByDash.getPos().getX() - 
		ballByDash.getPos().getX(), ballByDash.getPos().getY() - 
		ballByDash.getPos().getY()); 
		
	ballDistNoDash = hypot(ballNoDash.getPos().getX() - 
		ballNoDash.getPos().getX(), ballNoDash.getPos().getY() - 
		ballNoDash.getPos().getY()); 
	
	dribblePoint.x = bodyNoDash.getPos().getX() + dribbleVector.getX();
	dribblePoint.y = bodyNoDash.getPos().getY() + dribbleVector.getY();

	Point dribblePoint2;

	if (dribbleCount == 0 || dribbleCount == 1)
	{
		dribbleAngle = worldModel->getBody().getBodyDir();
	
		dribbleAngle += angle[dribbleCount];
		dribbleAngle = Degree::normalizeAngle(dribbleAngle);	

		dribbleVector.setAsPolar(kickableArea - noise2[dribbleCount] , 
			dribbleAngle);

		dribblePoint.x = bodyNoDash.getPos().getX() + dribbleVector.getX();
		dribblePoint.y = bodyNoDash.getPos().getY() + dribbleVector.getY();
		
	
		dribblePoint2.x = worldModel->getBall().getPos().getX() + 
			(dribblePoint.x - worldModel->getBall().getPos().getX()) * 
			kickPower[dribbleCount];
		dribblePoint2.y = worldModel->getBall().getPos().getY() + 
			(dribblePoint.y - worldModel->getBall().getPos().getY()) * 
			kickPower[dribbleCount];
	
#ifdef DRIBBLE_LOGLEVEL1
		LOG << "inja dribble ast : dribblePoint : " << dribblePoint << endl;
		LOG << "inja dribble ast : dribblePoint2 : " << dribblePoint2 << endl;
		LOG << "dribbleVector : " << dribbleVector.getMagnitude() << " " << dribbleVector.getDirection() << endl;
#endif
				
//		LOG << "dribblePoint2 : Before : " << dribblePoint2.x << " " << dribblePoint2.y << endl;
	
		float dribblePointDist = hypot(bodyNoDash.getPos().getX() - 
			dribblePoint2.x, bodyNoDash.getPos().getY() - dribblePoint2.y) + .1; 
		
		if ((dribblePointDist) >= kickableArea) 
			kickPower[dribbleCount] = 1;
	
		dribblePoint2.x = worldModel->getBall().getPos().getX() + 
			(dribblePoint.x - worldModel->getBall().getPos().getX()) * 
			kickPower[dribbleCount];
		dribblePoint2.y = worldModel->getBall().getPos().getY() + 
			(dribblePoint.y - worldModel->getBall().getPos().getY()) * 
			kickPower[dribbleCount];

//		LOG << "dribblePoint2 : After : " << dribblePoint2 << endl;
	}
	else
	{
		dribbleAngle = worldModel->getBody().getBodyDir();
	
		dribbleAngle += angle[dribbleCount];
		dribbleAngle = Degree::normalizeAngle(dribbleAngle);	
	
		dribbleVector.setAsPolar(kickableArea - noise2[dribbleCount], dribbleAngle);