pass.cpp

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

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

void
Pass::fillPassValuesByFactors(const KickCalculate &kickCalc, const PassFactors **factors,
							  float *valuesList[], unsigned num)
{
	float *values[MAX_FACTORS_NUM];

	for (unsigned i = 0; i < kickCalc.getSimulatesNum(); i++)
	{
		if (logLevel >= 3)
			LOG << "New kick: ballVel: "
				<< Point(kickCalc.getSimulate(i).getFirstBall().getVel().getMagnitude(),
						 kickCalc.getSimulate(i).getFirstBall().getVel().getDirection()) << endl;

		if (!kickCalc.getSimulate(i).isValid())
		{
			if (logLevel >= 3)
				LOG << "\tBREAK: is not valid." << endl;
			continue;
		}

		if (!kickCalc.getSimulate(i).existFastestPlayer())
		{
			if (logLevel >= 3)
				LOG << "\tBREAK: no fastest." << endl;
			continue;
		}

		if (!kickCalc.getSimulate(i).existFastestTmmPlayer())
		{
			if (logLevel >= 3)
				LOG << "\tBREAK: opp fastest: "
					<< kickCalc.getSimulate(i).getFastestPlayer().getTeamId() << " "
					<< kickCalc.getSimulate(i).getFastestPlayer().getUniNum() << endl;
			continue;
		}

		const KickInterceptPlayer &checkInterPlayer =
			kickCalc.getSimulate(i).getFastestTmmInterPlayer();

		if (logLevel >= 2)
			LOG << "CheckPlayer: " << checkInterPlayer.getPlayer().getTeamId()
				<< " " << checkInterPlayer.getPlayer().getUniNum() << endl;

		if (&checkInterPlayer.getPlayer() == 
			kickCalc.getSimulate(i).getKickPlayer())
		{
			if (logLevel >= 3)
				LOG << "\tBREAK: is kickPlayer." << endl;
			continue;
		}

		if (checkInterPlayer.getPlayer().isGoalie())
		{
			if (logLevel >= 3)
				LOG << "\tBREAK: is goalie." << endl;
			continue;
		}

		if (!checkInterPlayer.isExtraCatched())
		{
			if (logLevel >= 3)
				LOG << "\tBREAK: not extra catched." << endl;
			continue;
		}

/*		if (checkInterPlayer.getPlayer().getPos().getX() >
				worldModel->getOppOffsideLine() + PASS_OFFSIDE_DELTA_DIST)
		{
				if (logLevel >= 3)
				LOG << "\tBREAK: offside." << endl;
				continue;
		}*/

		for (unsigned j = 0; j < num; j++)
			values[j] = &valuesList[j][i];

		fillOnePassValuesByFactors(kickCalc.getSimulate(i),
								   factors, values, num);
	}
}

void Pass::fillOtherCrossValuesByFactors(const CrossCalculate &crossCalc,
										 const PassFactors &factors, float values[])
{
	float *valuesList[1];
	const PassFactors *factorsList[1] = {&factors};

	if (logLevel >= 1)
		LOG << "Cross Special Values:" << endl;

	for (unsigned i = 0; i < crossCalc.getSimulatesNum(); i++)
	{
		if (logLevel >= 3)
			LOG << "New cross kick: ballVel: "
				<< Point(crossCalc.getSimulate(i).getFirstBall().getVel().getMagnitude(),
						 crossCalc.getSimulate(i).getFirstBall().getVel().getDirection()) << endl;
		if (!crossCalc.getSimulate(i).isValid())
		{
			if (logLevel >= 3)
				LOG << "\tBREAK: is not valid." << endl;
			continue;
		}
		if (!crossCalc.getSimulate(i).existFastestTmmPlayer())
		{
			if (logLevel >= 3)
				LOG << "\tBREAK: no fastest." << endl;
			continue;
		}

		const KickInterceptPlayer &checkInterPlayer =
			crossCalc.getSimulate(i).getFastestTmmInterPlayer();

		if (logLevel >= 2)
			LOG << "CheckPlayer: " << checkInterPlayer.getPlayer().getTeamId()
				<< " " << checkInterPlayer.getPlayer().getUniNum() << endl;

		if (checkInterPlayer.getPlayer().isBody())
			continue;
		if (checkInterPlayer.getPlayer().isGoalie())
			continue;
		if (checkInterPlayer.getPlayer().getPos().getX() >
			worldModel->getOppOffsideLine() + PASS_OFFSIDE_DELTA_DIST)
			continue;

		valuesList[0] = &values[i + KICK_CALCULATES_NUM];
		fillOnePassValuesByFactors(crossCalc.getSimulate(i),
								   factorsList, valuesList);
	}
}

void Pass::calculateGlobalVars()
{
	logLevel = config["Pass"]["GlobalVars"]["LogLevel"].asInt();

	crossRate = config["Pass"]["GlobalVars"]["CrossRate"].asFloat();
	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 << "\t\t\t\tOffense SecureBall BreakOffside Cross" << endl;
	LOG << "Max Values:\t"
		<< "\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;
	}