pass.cpp

mersad源码 03年robocup 季军 可以研究一下大家

	crossAlpha = config["Pass"]["GlobalVars"]["CrossAlpha"].asFloat();
	offenseRate = config["Pass"]["GlobalVars"]["OffenseRate"].asFloat();
	offenseAlpha = config["Pass"]["GlobalVars"]["OffenseAlpha"].asFloat();
	secureBallRate = config["Pass"]["GlobalVars"]["SecureBallRate"].asFloat();
	secureBallAlpha = config["Pass"]["GlobalVars"]["SecureBallAlpha"].asFloat();
	breakOffsideRate = config["Pass"]["GlobalVars"]["BreakOffsideRate"].asFloat();
	breakOffsideAlpha = config["Pass"]["GlobalVars"]["BreakOffsideAlpha"].asFloat();

	if (worldModel->getBall().getPos().getX() < CROSS_PERMITTED_X)
		crossRate = 0;
}

void Pass::fillMaxValues()
{
	offenseMaxer = NOVALUE;
	secureBallMaxer = NOVALUE;
	breakOffsideMaxer = NOVALUE;
	crossMaxer = NOVALUE;

	if (offenseRate)
		for (unsigned i = 0; i < KICK_CALCULATES_NUM; i++)
			if (offenseMaxer == NOVALUE ||
				offenseValues[i] > offenseValues[offenseMaxer])
				offenseMaxer = i;

	if (secureBallRate)
		for (unsigned i = 0; i < KICK_CALCULATES_NUM; i++)
			if (secureBallMaxer == NOVALUE ||
				secureBallValues[i] > secureBallValues[secureBallMaxer])
				secureBallMaxer = i;

	if (breakOffsideRate)
		for (unsigned i = 0; i < KICK_CALCULATES_NUM; i++)
			if (breakOffsideMaxer == NOVALUE ||
				breakOffsideValues[i] > breakOffsideValues[breakOffsideMaxer])
				breakOffsideMaxer = i;

	if (crossRate)
		for (unsigned i = 0; i < KICK_CALCULATES_NUM + CROSS_CALCULATES_NUM; i++)
			if (crossMaxer == NOVALUE ||
				crossValues[i] > crossValues[crossMaxer])
				crossMaxer = i;

	LOG << "Max Values:"
		<< "\t" << (offenseMaxer != NOVALUE ? offenseValues[offenseMaxer] : -0xFFFF)
		<< "\t" << (secureBallMaxer != NOVALUE ? secureBallValues[secureBallMaxer] : -0xFFFF)
		<< "\t" << (breakOffsideMaxer != NOVALUE ? breakOffsideValues[breakOffsideMaxer] : -0xFFFF)
		<< "\t" << (crossMaxer != NOVALUE ? crossValues[crossMaxer]  : -0xFFFF) << endl;
}

void Pass::fillValues()
{
	float *values[MAX_FACTORS_NUM];
	const PassFactors *factors[MAX_FACTORS_NUM];
	unsigned num = 0;

	if (logLevel >= 1)
		LOG << "Pass weights sequence:";

	if (crossRate)
	{
		values[num] = crossValues;
		factors[num] = &crossFactors;
		num++;

		if (logLevel >= 1)
			LOG << " Cross";
	}

	if (offenseRate)
	{
		values[num] = offenseValues;
		factors[num] = &offenseFactors;
		num++;

		if (logLevel >= 1)
			LOG << " Offense";
	}

	if (secureBallRate)
	{
		values[num] = secureBallValues;
		factors[num] = &secureBallFactors;
		num++;

		if (logLevel >= 1)
			LOG << " SecureBall";
	}

	if (breakOffsideRate)
	{
		values[num] = breakOffsideValues;
		factors[num] = &breakOffsideFactors;
		num++;

		if (logLevel >= 1)
			LOG << " BreakOffside";
	}

	if (logLevel >= 1)
		LOG << endl;

	fillPassValuesByFactors(*curKickCalculate,
			factors, values, num);

	if (crossRate)
		fillOtherCrossValuesByFactors(*crossCalculate,
				crossFactors, crossValues);
}

void Pass::resetValues()
{
	for (unsigned i = 0; i < KICK_CALCULATES_NUM; i++)
	{
		crossValues[i] = -0xFFFF;
		offenseValues[i] = -0xFFFF;
		secureBallValues[i] = -0xFFFF;
		breakOffsideValues[i] = -0xFFFF;
	}

	for (unsigned i = 0; i < CROSS_CALCULATES_NUM; i++)
		crossValues[i + KICK_CALCULATES_NUM] = -0xFFFF;
}

void Pass::applyNoiseValues()
{
/*	unsigned neighbour1, neighbour2;
	float tempCrossValues[KICK_CALCULATES_NUM];
	float tempOffenseValues[KICK_CALCULATES_NUM];
	float tempSecureBallValues[KICK_CALCULATES_NUM];
	float tempBreakOffsideValues[KICK_CALCULATES_NUM];

	if (logLevel >= 2)
		LOG << "Pass::applyNoiseValues" << endl
			<< "   "
			<< "\t\t" << "cross"
			<< "\t" << "offense"
			<< "\t" << "secureBall"
			<< "\t" << "breakOffside" << endl;

	for (unsigned i = 0; i < KICK_CALCULATES_NUM; i++)
	{
	/u/u	worldModel->getCurKickCalculate().
				getNeighboursByDir(i, neighbour1, neighbour2);

		tempCrossValues[i] = ((crossValues[i] * 3) +
							  (crossValues[neighbour1] * 1) +
							  (crossValues[neighbour2] * 1)) / 5;

		tempOffenseValues[i] = ((offenseValues[i] * 3) +
							  (offenseValues[neighbour1] * 1) +
							  (offenseValues[neighbour2] * 1)) / 5;

		tempSecureBallValues[i] = ((secureBallValues[i] * 3) +
							  (secureBallValues[neighbour1] * 1) +
							  (secureBallValues[neighbour2] * 1)) / 5;

		tempBreakOffsideValues[i] = ((breakOffsideValues[i] * 3) +
							  (breakOffsideValues[neighbour1] * 1) +
							  (breakOffsideValues[neighbour2] * 1)) / 5;

	}

	for (unsigned i = 0; i < KICK_CALCULATES_NUM; i++)
	{
		crossValues[i] = tempCrossValues[i];
		offenseValues[i] = tempOffenseValues[i];
		secureBallValues[i] = tempSecureBallValues[i];
		breakOffsideValues[i] = tempBreakOffsideValues[i];

		if (logLevel >= 2)
			LOG << "i >"
				<< "\t\t" << crossValues[i]
				<< "\t" << offenseValues[i]
				<< "\t" << secureBallValues[i]
				<< "\t" << breakOffsideValues[i] << endl;
	}*/
}

float Pass::getTheBestPass(const KickInterceptCalculate *&interCalc)
{
	float offenseWeight = -0xFFFF;
	if (offenseRate && offenseValues[offenseMaxer] != -0xFFFF)
		offenseWeight = offenseValues[offenseMaxer] *
				offenseRate + offenseAlpha;

	float secureBallWeight = -0xFFFF;
	if (secureBallRate && secureBallValues[secureBallMaxer] != -0xFFFF)
		secureBallWeight = secureBallValues[secureBallMaxer] *
				secureBallRate + secureBallAlpha;

	float breakOffsideWeight = -0xFFFF;
	if (breakOffsideRate && breakOffsideValues[breakOffsideMaxer] != -0xFFFF)
		breakOffsideWeight = breakOffsideValues[breakOffsideMaxer] *
				breakOffsideRate + breakOffsideAlpha;

	float crossWeight = -0xFFFF;
	if (crossRate && crossValues[crossMaxer] != -0xFFFF)
		crossWeight = crossValues[crossMaxer] *
				crossRate + crossAlpha;

	LOG << "Max Weights:"
		<< "\t" << offenseWeight
		<< "\t" << secureBallWeight
		<< "\t" << breakOffsideWeight
		<< "\t" << crossWeight << endl;

	float max = offenseWeight;
	unsigned maxer = 1;

	if (secureBallWeight > max)
	{
		maxer = 2;
		max = secureBallWeight;
	}

	if (breakOffsideWeight > max)
	{
		maxer = 3;
		max = breakOffsideWeight;
	}

	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;
	}

	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;
}