interceptcalculate.cpp

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

{
	if (kickCycles > 0)
	{
		kickerSeeBallDelay = 0;

		tmmPosDevRate = -0.75;
		tmmSeeBallDelay = 2;
		tmmGoalieSeeBallDelay = 0;
		tmmSlowDashPower = 0;
		tmmFastDashPower = 100;
		tmmDirectDashPower = 0;
		tmmGoalieDirectDashPower = 0;

		oppPosDevRate = 0.5;
		oppSeeBallDelay = 0;
		oppGoalieSeeBallDelay = 0;
		oppSlowDashPower = 45;
		oppFastDashPower = 100;
		oppDirectDashPower = 60;
		oppGoalieDirectDashPower = 100;
	}
	else
	{
		kickerSeeBallDelay = 0; // only for reseting

		tmmPosDevRate = -0.3;
		tmmSeeBallDelay = 0;
		tmmGoalieSeeBallDelay = 0;
		tmmSlowDashPower = 30;
		tmmFastDashPower = 100;
		tmmDirectDashPower = 30;
		tmmGoalieDirectDashPower = 30;

		oppPosDevRate = 0.3;
		oppSeeBallDelay = 0;
		oppGoalieSeeBallDelay = 0;
		oppSlowDashPower = 50;
		oppFastDashPower = 100;
		oppDirectDashPower = 90;
		oppGoalieDirectDashPower = 100;
	}
}

void InterceptCalculate::startSession(unsigned kickCyclesArg,
		const Player *kickPlayerArg, const Player *blockedPlayerArg)
{
	setLogging(false);
	playersNum = 0;
	kickPlayer = kickPlayerArg;
	blockedPlayer = blockedPlayerArg;
	kickCycles = kickCyclesArg;
	shareCycles = DEFAULT_SHARE_CYCLES;

	initTeamsProps();
}

void InterceptCalculate::addPlayer(const Player &player, bool kickPlayerFlag,
		bool blockedPlayerFlag, bool checkForPenaltyBox)
{
	float posDevDashDist;

	interceptPlayers[playersNum].setLogging(isLogging());

	if (kickPlayerFlag)
		interceptPlayers[playersNum].init(player, virtualBall,
				kickPlayerFlag, kickCycles, kickerSeeBallDelay,
				0, player.getMaxPower(), 0, 0, false, checkForPenaltyBox);

	else if (player.getTeamId() == TID_TEAMMATE)
	{
		posDevDashDist = tmmPosDevRate * player.getPosDeviation();

		if (player.isGoalie())
			interceptPlayers[playersNum].init(player, virtualBall,
					kickPlayerFlag, kickCycles, tmmGoalieSeeBallDelay,
					tmmSlowDashPower, tmmFastDashPower,
					tmmGoalieDirectDashPower, posDevDashDist,
					blockedPlayerFlag, checkForPenaltyBox);
		else
			interceptPlayers[playersNum].init(player, virtualBall,
					kickPlayerFlag, kickCycles, tmmSeeBallDelay,
					tmmSlowDashPower, tmmFastDashPower,
					tmmDirectDashPower, posDevDashDist, blockedPlayerFlag,
					checkForPenaltyBox);
	}

	else if (player.getTeamId() == TID_OPPONENT)
	{
		posDevDashDist = oppPosDevRate * player.getPosDeviation();

		if (player.isGoalie())
			interceptPlayers[playersNum].init(player, virtualBall,
					kickPlayerFlag, kickCycles, oppGoalieSeeBallDelay,
					oppSlowDashPower, oppFastDashPower,
					oppGoalieDirectDashPower, posDevDashDist,
					blockedPlayerFlag, checkForPenaltyBox);
		else
			interceptPlayers[playersNum].init(player, virtualBall,
					kickPlayerFlag, kickCycles, oppSeeBallDelay,
					oppSlowDashPower, oppFastDashPower,
					oppDirectDashPower, posDevDashDist, blockedPlayerFlag,
					checkForPenaltyBox);
	}
	else
		assert(0);

	playersNum++;
}

void InterceptCalculate::updateByWorldModel(const WorldModel *worldModel,
		bool removeBody, bool removeTmm, bool removeOpp)
{
	unsigned i;

	// adding the ball
	virtualBall = worldModel->getBall();

	// adding players
	if (!removeBody)
		addPlayer(worldModel->getBody(),
			(&worldModel->getBody() == kickPlayer),
			(&worldModel->getBody() == blockedPlayer));

	for (i = 0; i < FULL_PLAYERS_NUM; i++)
	{
		if (!removeTmm)
			if (worldModel->getFullPlayer(TID_TEAMMATE, i).isValid() &&
				!worldModel->getFullPlayer(TID_TEAMMATE, i).isBody())
				addPlayer(worldModel->getFullPlayer(TID_TEAMMATE, i),
					(&worldModel->getFullPlayer(TID_TEAMMATE, i) == kickPlayer),
					(&worldModel->getFullPlayer(TID_TEAMMATE, i) == blockedPlayer));

		if (!removeOpp)
			if (worldModel->getFullPlayer(TID_OPPONENT, i).isValid())
				addPlayer(worldModel->getFullPlayer(TID_OPPONENT, i),
					(&worldModel->getFullPlayer(TID_OPPONENT, i) == kickPlayer),
					(&worldModel->getFullPlayer(TID_OPPONENT, i) == blockedPlayer));
	}

	for (i = 0; i < HALF_PLAYERS_NUM; i++)
	{
		if (!removeTmm)
			if (worldModel->getHalfPlayer(TID_TEAMMATE, i).isValid())
				addPlayer(worldModel->getHalfPlayer(TID_TEAMMATE, i),
					(&worldModel->getHalfPlayer(TID_TEAMMATE, i) == kickPlayer),
					(&worldModel->getHalfPlayer(TID_TEAMMATE, i) ==	blockedPlayer));

		if (!removeOpp)
			if (worldModel->getHalfPlayer(TID_OPPONENT, i).isValid())
				addPlayer(worldModel->getHalfPlayer(TID_OPPONENT, i),
					(&worldModel->getHalfPlayer(TID_OPPONENT, i) == kickPlayer),
					(&worldModel->getHalfPlayer(TID_OPPONENT, i) ==	blockedPlayer));
	}
}

void InterceptCalculate::getReadyToRun()
{
	// Resetting after running Intercepts variables
	playMode = PM_PLAY_ON;
	checkedPlayersNum = 0;
	fastestPlayerNum = NOVALUE;
	fastestTmmPlayerNum = NOVALUE;
	fastestOppPlayerNum = NOVALUE;
	fastestCheckedPlayerNum = NOVALUE;
	fastestTmmCheckedPlayerNum = NOVALUE;
	fastestOppCheckedPlayerNum = NOVALUE;

	for (unsigned i = 0;i < playersNum;i++)
		interceptPlayers[i].getReadyToRun();
}

void InterceptCalculate::simulateVirtualBall()
{
	virtualBall.setPos() += virtualBall.getVel();
	virtualBall.setVel() *= virtualBall.getDecay();
}

void InterceptCalculate::finalizeIntercepts()
{
	prepareSum();
}

bool InterceptCalculate::existFastestPlayer() const
{
	if (fastestPlayerNum == NOVALUE)
		return false;
	return true;
}

bool InterceptCalculate::existFastestTmmPlayer() const
{
	if (fastestTmmPlayerNum == NOVALUE)
		return false;
	return true;
}

bool InterceptCalculate::existFastestOppPlayer() const
{
	if (fastestOppPlayerNum == NOVALUE)
		return false;
	return true;
}

bool InterceptCalculate::isFastestPlayer(const Player &player) const
{
	if (getFastestPlayer().getModel() == player.getModel() &&
		getFastestPlayer().getTeamId() == player.getTeamId() &&
		getFastestPlayer().getUniNum() == player.getUniNum())
		return true;
	return false;
}

unsigned InterceptCalculate::getTmmCheckedPlayersNum() const
{
	unsigned tmmCounter = 0;

	for (unsigned i = 0; i < checkedPlayersNum; i++)
		if (getCheckedInterPlayer(i).getPlayer().getTeamId() == TID_TEAMMATE)
			tmmCounter++;

	return tmmCounter;
}

unsigned InterceptCalculate::getOppCheckedPlayersNum() const
{
	unsigned oppCounter = 0;

	for (unsigned i = 0; i < checkedPlayersNum; i++)
		if (getCheckedInterPlayer(i).getPlayer().getTeamId() == TID_OPPONENT)
			oppCounter++;

	return oppCounter;
}

unsigned InterceptCalculate::getCheckedListNum(const Player &player) const
{
	for (unsigned i = 0; i < checkedPlayersNum; i++)
		if (getCheckedInterPlayer(i).getPlayer().getModel() == player.getModel() &&
			getCheckedInterPlayer(i).getPlayer().getTeamId() == player.getTeamId() &&
			getCheckedInterPlayer(i).getPlayer().getUniNum() == player.getUniNum())
				return i;

	return NOVALUE;
}

unsigned InterceptCalculate::getOppPlayersBeforeLine(float x) const
{
	unsigned counter = 0;

	for (unsigned i = 0; i < playersNum; i++)
		if (interceptPlayers[i].getPlayer().getTeamId() == TID_OPPONENT &&
			interceptPlayers[i].getPlayer().getPos().getX() <= x)
				counter++;

	return counter;
}

unsigned InterceptCalculate::getOppPlayersBetweenLines(float x1,
		float x2) const
{
	return abs((int)getOppPlayersBeforeLine(x1) -
			(int)getOppPlayersBeforeLine(x2));
}

const Player &InterceptCalculate::getFastestPlayer() const
{
	return interceptPlayers[fastestPlayerNum].getPlayer();
}

const Player &InterceptCalculate::getFastestTmmPlayer() const
{
	return interceptPlayers[fastestTmmPlayerNum].getPlayer();
}

const Player &InterceptCalculate::getFastestOppPlayer() const
{
	return interceptPlayers[fastestOppPlayerNum].getPlayer();
}

const InterceptPlayer &InterceptCalculate::getFastestInterPlayer() const
{
	return interceptPlayers[fastestPlayerNum];
}

const InterceptPlayer &InterceptCalculate::getFastestTmmInterPlayer() const
{
	return interceptPlayers[fastestTmmPlayerNum];
}

const InterceptPlayer &InterceptCalculate::getFastestOppInterPlayer() const
{
	return interceptPlayers[fastestOppPlayerNum];
}

const InterceptPlayer &InterceptCalculate::getCheckedInterPlayer(unsigned num) const
{
	return interceptPlayers[checkedPlayers[num]];
}

void InterceptCalculate::logCheckedPlayers() const
{
	LOG << "InterceptCalculate checked players:" << endl;

	for (unsigned i = 0; i < checkedPlayersNum; i++)
		LOG << "\t" << i << ": "
			<< getCheckedInterPlayer(i).getPlayer().getTeamId() << " "
			<< getCheckedInterPlayer(i).getPlayer().getUniNum() << " "
			<< getCheckedInterPlayer(i).getInterTime() << endl;
}

void InterceptCalculate::setBlockedBall()
{
	virtualBall.setVel() = blockedBallVel;
	virtualBall.setDecay(1);
}

void InterceptCalculate::getNearestOppDistDirToFastest(float &dist, float &dir)
{
	unsigned miner = NOVALUE;
	float min = 0xFFFF;

	if (existFastestOppPlayer())
	{
		dist = 0;
		dir = 0;

		return;
	}

	for (unsigned i = 0; i < playersNum; i++)
		if (interceptPlayers[i].getPlayer().getTeamId() == TID_OPPONENT)
		{
			float cur = interceptPlayers[i].getPlayer().getDistance(
					getFastestInterPlayer().getInterPoint()) -
					interceptPlayers[i].getDashDist();
			if (miner == NOVALUE || cur < min)
			{
				miner = i;
				min = cur;
			}
		}

	if (miner == NOVALUE)
	{
		dist = NOVALUE;
		dir = NOVALUE;

		return;
	}

	dir = Degree::arcTan2((interceptPlayers[miner].getPlayer().getPos().getY() -
			getFastestInterPlayer().getInterPoint().y),
			(interceptPlayers[miner].getPlayer().getPos().getX() -
			getFastestInterPlayer().getInterPoint().x));

	dist = interceptPlayers[miner].getPlayer().getDistance(
				getFastestInterPlayer().getInterPoint()) -
				interceptPlayers[miner].getDashDist();
}

// Getting functions
bool InterceptCalculate::isLogging() const
{
	return loggingFlag;
}

unsigned InterceptCalculate::getPlayersNum() const
{
	return playersNum;
}

unsigned InterceptCalculate::getFastestPlayerNum() const
{
	return fastestPlayerNum;
}

unsigned InterceptCalculate::getFastestTmmPlayerNum() const
{
	return fastestTmmPlayerNum;
}

unsigned InterceptCalculate::getFastestOppPlayerNum() const
{
	return fastestOppPlayerNum;
}

unsigned InterceptCalculate::getCheckedPlayersNum() const
{
	return checkedPlayersNum;
}

unsigned InterceptCalculate::getFastestCheckedPlayerNum() const
{
	return fastestCheckedPlayerNum;
}

unsigned InterceptCalculate::getFastestTmmCheckedPlayerNum() const
{
	return fastestTmmCheckedPlayerNum;
}

unsigned InterceptCalculate::getFastestOppCheckedPlayerNum() const
{
	return fastestOppCheckedPlayerNum;
}

PlayMode InterceptCalculate::getPlayMode() const
{
	return playMode;
}

const Ball &InterceptCalculate::getVirtualBall() const
{
	return virtualBall;
}

const Player *InterceptCalculate::getKickPlayer() const
{
	return kickPlayer;
}

// Setting functions
void InterceptCalculate::setLogging(bool loggingFlagArg)
{
	loggingFlag = loggingFlagArg;
}

void InterceptCalculate::setKickCycles(unsigned kickCyclesArg)
{
	kickCycles = kickCyclesArg;
}

void InterceptCalculate::setShareCycles(unsigned shareCyclesArg)
{
	shareCycles = shareCyclesArg;
}

void InterceptCalculate::setKickerSeeBallDelay(unsigned kickerSeeBallDelayArg)
{
	kickerSeeBallDelay = kickerSeeBallDelayArg;
}

void InterceptCalculate::setTmmSlowDashPower(float tmmSlowDashPowerArg)
{
	tmmSlowDashPower = tmmSlowDashPowerArg;
}

void InterceptCalculate::setTmmFastDashPower(float tmmFastDashPowerArg)
{
	tmmFastDashPower = tmmFastDashPowerArg;
}

void InterceptCalculate::setTmmDirectDashPower(float tmmDirectDashPowerArg)
{
	tmmDirectDashPower = tmmDirectDashPowerArg;
}

void InterceptCalculate::setTmmGoalieDirectDashPower(float tmmGoalieDirectDashPowerArg)
{
	tmmGoalieDirectDashPower = tmmGoalieDirectDashPowerArg;
}

void InterceptCalculate::setTmmSeeBallDelay(unsigned tmmSeeBallDelayArg)
{
	tmmSeeBallDelay = tmmSeeBallDelayArg;
}

void InterceptCalculate::setTmmGoalieSeeBallDelay(unsigned tmmGoalieSeeBallDelayArg)
{
	tmmGoalieSeeBallDelay = tmmGoalieSeeBallDelayArg;
}

void InterceptCalculate::setTmmPosDevRate(float tmmPosDevRateArg)
{
	tmmPosDevRate = tmmPosDevRateArg;
}

void InterceptCalculate::setOppSlowDashPower(float oppSlowDashPowerArg)
{
	oppSlowDashPower = oppSlowDashPowerArg;
}

void InterceptCalculate::setOppFastDashPower(float oppFastDashPowerArg)
{
	oppFastDashPower = oppFastDashPowerArg;
}

void InterceptCalculate::setOppDirectDashPower(float oppDirectDashPowerArg)
{
	oppDirectDashPower = oppDirectDashPowerArg;
}

void InterceptCalculate::setOppGoalieDirectDashPower(float oppGoalieDirectDashPowerArg)
{
	oppGoalieDirectDashPower = oppGoalieDirectDashPowerArg;
}

void InterceptCalculate::setOppSeeBallDelay(unsigned oppSeeBallDelayArg)
{
	oppSeeBallDelay = oppSeeBallDelayArg;
}

void InterceptCalculate::setOppGoalieSeeBallDelay(unsigned oppGoalieSeeBallDelayArg)
{
	oppGoalieSeeBallDelay = oppGoalieSeeBallDelayArg;
}

void InterceptCalculate::setOppPosDevRate(float oppPosDevRateArg)
{
	oppPosDevRate = oppPosDevRateArg;
}

void InterceptCalculate::setVirtualBall(const Ball &virtualBallArg)
{
	virtualBall = virtualBallArg;
}

void InterceptCalculate::setBlockedBallVel(const Vector &blockedBallVelArg)
{
	blockedBallVel = blockedBallVelArg;
}

InterceptPlayer &InterceptCalculate::setLastInterPlayer()
{
	return interceptPlayers[playersNum - 1];
}