pass.cpp

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

	if (crossWeight > max)
	{
		maxer = 4;
		max = crossWeight;
	}

	if (max == -0xFFFF)
	{
		interCalc = NULL;
		return -0xFFFF;
	}

	switch (maxer)
	{
	case 1:
			interCalc = &curKickCalculate->getSimulate(offenseMaxer);
			passModel = PAM_OFFENSE;
			break;

	case 2:
			interCalc = &curKickCalculate->getSimulate(secureBallMaxer);
			passModel = PAM_SECURE_BALL;
			break;

	case 3:
			interCalc = &curKickCalculate->getSimulate(breakOffsideMaxer);
			passModel = PAM_BREAK_OFFSIDE;
			break;

	case 4:
			if (crossMaxer < KICK_CALCULATES_NUM)
			{
				interCalc = &curKickCalculate->getSimulate(crossMaxer);
				LOG << "Cross pass executed." << endl;
			}
			else
			{
				interCalc = &crossCalculate->
					getSimulate(crossMaxer - KICK_CALCULATES_NUM);
				LOG << "Cross special pass executed." << endl;
			}
			passModel = PAM_CROSS;
			break;

	default:
			assert(0);
	}

	return max;
}

float Pass::getShootDirValue(const Point &point, const WorldModel *worldModel)
{
	Vector goalUpVector, goalDownVector, goalieVector;
	const Player *oppGoalie = worldModel->getOppGoalie();

	goalUpVector.setByPoints(point, Point(52.5, 7));
	goalDownVector.setByPoints(point, Point(52.5, -7));

	if (oppGoalie == NULL)
		return fabs(Degree::getDeltaAngle(goalDownVector.getDirection(),
										  goalUpVector.getDirection()));

	goalieVector.setByPoints(point, oppGoalie->getPos());

	float upDeltaAngle = Degree::getDeltaAngle(
		goalieVector.getDirection(), goalUpVector.getDirection());
	float downDeltaAngle = Degree::getDeltaAngle(
		goalieVector.getDirection(), goalDownVector.getDirection());

	if ((upDeltaAngle > 0 && downDeltaAngle > 0) ||
		(upDeltaAngle < 0 && downDeltaAngle < 0))
		return fabs(Degree::getDeltaAngle(goalDownVector.getDirection(),
										  goalUpVector.getDirection()));

	return fmax(fabs(upDeltaAngle), fabs(downDeltaAngle));
}

float Pass::getPlanWeight(unsigned kickerNum, unsigned passNum,
						  const Point &kickPoint)
{
	if (kickerNum == 5)
	{
		if (6 <= passNum && passNum <= 9)
			return PW_VERY_BAD;
		if (passNum == 10 || passNum == 11)
			return PW_VERY_GOOD;
		if (passNum <= 4)
			return PW_GOOD;
	}

	if (6 <= kickerNum && kickerNum <= 9)
	{
		if (passNum == 5)
			return PW_NOTHING;
		if (6 <= passNum && passNum <= 9)
			return PW_VERY_BAD;
		if (passNum == 10 || passNum == 11)
			return PW_VERY_GOOD;
		if (passNum <= 4)
			return PW_GOOD;
	}

/*	if (kickerNum == 2)
	{
		if (passNum == 10)
		{
			if (kickPoint.x > 35)
				return PW_NOTHING;
			else
				return PW_VERY_GOOD;
		}
		if (passNum == 3 || passNum == 4)
			return PW_GOOD;
	}

	if (kickerNum == 4)
	{
		if (passNum == 11)
		{
			if (kickPoint.x > 35)
				return PW_NOTHING;
			else
				return PW_VERY_GOOD;
		}
		if (passNum == 3 || passNum == 2)
			return PW_GOOD;
	}

	if (kickerNum == 3)
	{
		if (passNum == 2 || passNum == 4)
			return PW_GOOD;
		if (passNum == 10 || passNum == 11)
		{
			if (kickPoint.x > 35)
				return PW_NOTHING;
			else
				return PW_GOOD;
		}
	}

	if (kickerNum == 10 || kickerNum == 11)
	{
		if (kickPoint.x > 37.5)
			return PW_GOOD;
		else
			return PW_BAD;
	}*/

	if (isInPlayers(worldModel->getBody().getUniNum(), "234AB"))
		return PW_GOOD;

	return 0;
}

// getting functions
float Pass::getPassValue() const
{
	return passValue;
}

PassModel Pass::getPassModel() const
{
	return passModel;
}

const Player *Pass::getPassPlayer() const
{
	return passPlayer;
}

const KickInterceptCalculate *Pass::getPassInterCalc() const
{
	return passInterCalc;
}

// setting functions
void
Pass::setCurKickCalculate(const KickCalculate *curKickCalculateArg)
{
	curKickCalculate = curKickCalculateArg;
}


// class PassLibrary
PassLibrary::PassLibrary(const WorldModel *worldModel): Pass(worldModel)
{
}

void PassLibrary::calculate()
{
	LOG << "PassLibrary::calculate" << endl;

	delete passCommand;
	passCommand = NULL;

	if (logLevel >= 1)
		loadPassFactors();

	calculateGlobalVars();

	if (crossRate)
		crossCalculate->update(worldModel);

	resetValues();
	fillValues();
}

ExactPassFlag PassLibrary::getTheBestPass(unsigned models, unsigned number,
		float passAngleFrom, float passAngleTo,
		float playerAngleFrom, float playerAngleTo) const
{
	LOG << "PassLibrary::getTheBestPass" << endl;

	ExactPassFlag flag;

	unsigned offenseMaxer = NOVALUE;
	unsigned secureBallMaxer = NOVALUE;
	unsigned breakOffsideMaxer = NOVALUE;
	unsigned crossMaxer = NOVALUE;

	passAngleFrom = Degree::normalizeAngle(passAngleFrom);
	passAngleTo = Degree::normalizeAngle(passAngleTo);

	if (offenseRate && (models & BPM_OFFENSE))
		for (unsigned i = 0; i < KICK_CALCULATES_NUM; i++)
			if (offenseValues[i] != -0xFFFF &&
				(number == BPN_ALL ||
				 (number > 11 && // Half players are also available.
				  curKickCalculate->getSimulate(i).getFastestTmmInterPlayer().
				 		getPlayer().getModel() == PLM_HALF) ||
				 (curKickCalculate->getSimulate(i).getFastestTmmInterPlayer().
				 		getPlayer().getUniNum() == Basics::baghimande(number - 1, 11) + 1)) &&
				(curKickCalculate->getSimulate(i).getFirstBall().
						getVel().getDirection() >= passAngleFrom &&
				 curKickCalculate->getSimulate(i).getFirstBall().
						getVel().getDirection() <= passAngleTo) &&
				(curKickCalculate->getSimulate(i).getFastestTmmInterPlayer().
						getPlayer().getAbsVec().getDirection() >= playerAngleFrom &&
				 curKickCalculate->getSimulate(i).getFastestTmmInterPlayer().
						getPlayer().getAbsVec().getDirection() <= playerAngleTo) &&
				(offenseMaxer == NOVALUE ||
				 offenseValues[i] > offenseValues[offenseMaxer]))
				offenseMaxer = i;

	if (secureBallRate && (models & BPM_SECUREBALL))
		for (unsigned i = 0; i < KICK_CALCULATES_NUM; i++)
			if (secureBallValues[i] != -0xFFFF &&
				(number == BPN_ALL ||
				 (number > 11 && // Half players are also available.
				  curKickCalculate->getSimulate(i).getFastestTmmInterPlayer().
				 		getPlayer().getModel() == PLM_HALF) ||
				 (curKickCalculate->getSimulate(i).getFastestTmmInterPlayer().
				 		getPlayer().getUniNum() == Basics::baghimande(number - 1, 11) + 1)) &&
				(curKickCalculate->getSimulate(i).getFirstBall().
						getVel().getDirection() >= passAngleFrom &&
				 curKickCalculate->getSimulate(i).getFirstBall().
						getVel().getDirection() <= passAngleTo) &&
				(curKickCalculate->getSimulate(i).getFastestTmmInterPlayer().
						getPlayer().getAbsVec().getDirection() >= playerAngleFrom &&
				 curKickCalculate->getSimulate(i).getFastestTmmInterPlayer().
						getPlayer().getAbsVec().getDirection() <= playerAngleTo) &&
				(secureBallMaxer == NOVALUE ||
				 secureBallValues[i] > secureBallValues[secureBallMaxer]))
				secureBallMaxer = i;

	if (breakOffsideRate && (models & BPM_BREAKOFFSIDE))
		for (unsigned i = 0; i < KICK_CALCULATES_NUM; i++)
			if (breakOffsideValues[i] != -0xFFFF &&
				(number == BPN_ALL ||
				 (number > 11 && // Half players are also available.
				  curKickCalculate->getSimulate(i).getFastestTmmInterPlayer().
				 		getPlayer().getModel() == PLM_HALF) ||
				  (curKickCalculate->getSimulate(i).getFastestTmmInterPlayer().
				 		getPlayer().getUniNum() == Basics::baghimande(number - 1, 11) + 1)) &&
				(curKickCalculate->getSimulate(i).getFirstBall().
						getVel().getDirection() >= passAngleFrom &&
				 curKickCalculate->getSimulate(i).getFirstBall().
						getVel().getDirection() <= passAngleTo) &&
				(curKickCalculate->getSimulate(i).getFastestTmmInterPlayer().
						getPlayer().getAbsVec().getDirection() >= playerAngleFrom &&
				 curKickCalculate->getSimulate(i).getFastestTmmInterPlayer().
						getPlayer().getAbsVec().getDirection() <= playerAngleTo) &&
				(breakOffsideMaxer == NOVALUE ||
				 breakOffsideValues[i] > breakOffsideValues[breakOffsideMaxer]))
				breakOffsideMaxer = i;

	if (crossRate && (models & BPM_CROSS))
	{
		for (unsigned i = 0; i < KICK_CALCULATES_NUM; i++)
			if (crossValues[i] != -0xFFFF &&
				(number == BPN_ALL ||
				 (number > 11 && // Half players are also available.
				  curKickCalculate->getSimulate(i).getFastestTmmInterPlayer().
				 		getPlayer().getModel() == PLM_HALF) ||
				 (curKickCalculate->getSimulate(i).getFastestTmmInterPlayer().
				 		getPlayer().getUniNum() == Basics::baghimande(number - 1, 11) + 1)) &&
				(curKickCalculate->getSimulate(i).getFirstBall().
						getVel().getDirection() >= passAngleFrom &&
				 curKickCalculate->getSimulate(i).getFirstBall().
						getVel().getDirection() <= passAngleTo) &&
				(curKickCalculate->getSimulate(i).getFastestTmmInterPlayer().
						getPlayer().getAbsVec().getDirection() >= playerAngleFrom &&
				 curKickCalculate->getSimulate(i).getFastestTmmInterPlayer().
						getPlayer().getAbsVec().getDirection() <= playerAngleTo) &&
				(crossMaxer == NOVALUE ||
				 crossValues[i] > crossValues[crossMaxer]))
				crossMaxer = i;

		for (unsigned i = KICK_CALCULATES_NUM;
				i < KICK_CALCULATES_NUM + CROSS_CALCULATES_NUM; i++)
			if (crossValues[i] != -0xFFFF &&
				(number == BPN_ALL ||
				 (number > 11 && // Half players are also available.
				  crossCalculate->getSimulate(i - KICK_CALCULATES_NUM).getFastestTmmInterPlayer().
				 		getPlayer().getModel() == PLM_HALF) ||
				 (crossCalculate->getSimulate(i - KICK_CALCULATES_NUM).getFastestTmmInterPlayer().
				 		getPlayer().getUniNum() == Basics::baghimande(number - 1, 11) + 1)) &&
				(crossCalculate->getSimulate(i - KICK_CALCULATES_NUM).
						getFirstBall().getVel().getDirection() >= passAngleFrom &&
				 crossCalculate->getSimulate(i - KICK_CALCULATES_NUM).
				 		getFirstBall().getVel().getDirection() <= passAngleTo) &&
				(crossCalculate->getSimulate(i - KICK_CALCULATES_NUM).getFastestTmmInterPlayer().
						getPlayer().getAbsVec().getDirection() >= playerAngleFrom &&
				 crossCalculate->getSimulate(i - KICK_CALCULATES_NUM).getFastestTmmInterPlayer().
						getPlayer().getAbsVec().getDirection() <= playerAngleTo) &&
				(crossMaxer == NOVALUE ||
				 crossValues[i] > crossValues[crossMaxer]))
				crossMaxer = i;
	}

	bool haveSuggested = false;
	if (worldModel->getHearedSuggestPassTime() == worldModel->getCurTime() &&
		(models & BPM_SUGGESTED))
	{
		LOG << "Suggested pass:" << endl
			<< "\tPlayer: " << worldModel->getHearedSuggestPassNum() << endl
			<< "\tWeight: " << worldModel->getHearedSuggestPassWeight() << endl
			<< "\tSpeed: " << worldModel->getHearedSuggestPassSpeed() << endl
			<< "\tDir: " << worldModel->getHearedSuggestPassDir() << endl;

		KickToDirectionVelocity basicKick(AT_PASS,
				worldModel->getHearedSuggestPassDir(),
				worldModel->getHearedSuggestPassSpeed(),
				worldModel->getBall(), worldModel->getBody());

		if (!basicKick.isPossible())
		{
			LOG << "Suggested pass refused: kick is not possible." << endl;
			haveSuggested = false;
		}
		else
		{
			LOG << "Suggested pass accepted." << endl;
			haveSuggested = true;
		}
	}

	LOG << "\t\t\t\tOffense SecureBall BreakOffside Cross Suggested" << endl;
	LOG << "Max Values:\t"
		<< "\t" << (offenseMaxer != NOVALUE ? offenseValues[offenseMaxer] : -0xFFFF)
		<< "\t" << (secureBallMaxer != NOVALUE ?