kickcalculate.cpp

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

/*
 *  Copyright 2002-2005, Mersad Team, Allameh Helli High School (NODET).
 *
 *  This program is free software, you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 *  GNU Library General Public License for more details.
 *
 *  This file is created by: Ahmad Boorghany
 *
 *  Released on Monday 1 August 2005, 10 Mordad 1384 by Mersad RoboCup Team.
 *  For more information please read README file.
*/

#include <cmath>

#include <Logger.h>
#include <Degree.h>
#include <Defines.h>
#include <Command.h>
#include <BasicKick.h>
#include <WorldModel.h>
#include <KickCalculate.h>


//#define KICK_CALCULATE_LOGLEVEL1


using namespace std;
using namespace Degree;

// class KickInterceptPlayer

void KickInterceptPlayer::init(const InterceptPlayer &interPlayer)
{
	extraCatchedFlag = interPlayer.isExtraCatched();
	dashDist = interPlayer.getDashDist();
	interceptTime = interPlayer.getInterTime();
	player = &interPlayer.getPlayer();
	interceptPoint = interPlayer.getInterPoint();
}

// Getting functions
bool KickInterceptPlayer::isExtraCatched() const
{
	return extraCatchedFlag;
}

float KickInterceptPlayer::getDashDist() const
{
	return dashDist;
}

unsigned KickInterceptPlayer::getInterTime() const
{
	return interceptTime;
}

const Player &KickInterceptPlayer::getPlayer() const
{
	return *player;
}

const Point &KickInterceptPlayer::getInterPoint() const
{
	return interceptPoint;
}


// class KickInterceptCalculate
KickInterceptCalculate::KickInterceptCalculate()
{
	kickCommand = NULL;
}

KickInterceptCalculate::~KickInterceptCalculate()
{
}

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

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

	return tmmCounter;
}

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

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

	return oppCounter;
}

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

	return NOVALUE;
}

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

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

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

bool KickInterceptCalculate::isFastestPlayer(const Player &player) const
{
	if (checkedPlayers[fastestPlayerNum].getPlayer().getModel() ==
				player.getModel() &&
		checkedPlayers[fastestPlayerNum].getPlayer().getTeamId() ==
				player.getTeamId() &&
		checkedPlayers[fastestPlayerNum].getPlayer().getUniNum() ==
				player.getUniNum())
		return true;
	return false;
}

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

const KickInterceptPlayer& KickInterceptCalculate::getFastestInterPlayer() const
{
	return checkedPlayers[fastestPlayerNum];
}

const KickInterceptPlayer& KickInterceptCalculate::getFastestTmmInterPlayer() const
{
	return checkedPlayers[fastestTmmPlayerNum];
}

const KickInterceptPlayer& KickInterceptCalculate::getFastestOppInterPlayer() const
{
	return checkedPlayers[fastestOppPlayerNum];
}

void KickInterceptCalculate::saveResults(const InterceptCalculate &interCalc)
{
	virtualBall.setPos() = interCalc.getVirtualBall().getPos();
	virtualBall.setVel() = interCalc.getVirtualBall().getVel();

	playMode = interCalc.getPlayMode();
	checkedPlayersNum = interCalc.getCheckedPlayersNum();
	fastestPlayerNum = interCalc.getFastestCheckedPlayerNum();
	fastestTmmPlayerNum = interCalc.getFastestTmmCheckedPlayerNum();
	fastestOppPlayerNum = interCalc.getFastestOppCheckedPlayerNum();

	kickPlayer = interCalc.getKickPlayer();

	for (unsigned i = 0; i < checkedPlayersNum; i++)
		checkedPlayers[i].init(interCalc.getCheckedInterPlayer(i));
}

void KickInterceptCalculate::init(const WorldModel *worldModel,
		const KickCommand *kickCommandArg, InterceptCalculate &interCalc)
{
	if (!kickCommandArg)
	{
		setValid(false);
		return;
	}

	delete kickCommand;
	kickCommand = new KickCommand(*kickCommandArg);

	firstBall = worldModel->getBall();
	firstBall.simulateByAction(worldModel->getBody(), kickCommand);

#ifdef KICK_CALCULATE_LOGLEVEL1
	LOG << "New kick: " << kickCommand->toString() << " Ball vel: "
		<< Point(firstBall.getVel().getMagnitude(),
				 firstBall.getVel().getDirection()) << endl;
#endif

	if (worldModel->getSeeDeltaCycle(firstBall.getVel().getDirection(), 0.2) >
			KICK_CALC_MAX_SEE_DELTA_CYCLE)
	{

#ifdef KICK_CALCULATE_LOGLEVEL1
		LOG << "Break: did not see." << endl;
#endif

		setValid(false);
		return;
	}

	setValid(true);

	interCalc.setVirtualBall(firstBall);
	interCalc.run();

	saveResults(interCalc);

	// Initing Informations
	passedOppPlayers = 0;
	nearestOppToFastestDist = 0xFFFF;
	nearestOppToFastestDir = 180;

	if (interCalc.existFastestPlayer())
	{
		if (firstBall.getPos().getX() <
			interCalc.getFastestInterPlayer().getInterPoint().x)
			passedOppPlayers = interCalc.getOppPlayersBetweenLines(
					firstBall.getPos().getX(),
					interCalc.getFastestInterPlayer().getInterPoint().x);

		interCalc.getNearestOppDistDirToFastest(
				nearestOppToFastestDist, nearestOppToFastestDir);
	}
}

// Getting functions
unsigned KickInterceptCalculate::getKickCycles() const
{
	return kickCycles;
}

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

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

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

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

bool KickInterceptCalculate::isValid() const
{
	return validFlag;
}

unsigned KickInterceptCalculate::getPassedOppPlayers() const
{
	return passedOppPlayers;
}

float KickInterceptCalculate::getNearestOppToFastestDist() const
{
	return nearestOppToFastestDist;
}

float KickInterceptCalculate::getNearestOppToFastestDir() const
{
	return nearestOppToFastestDir;
}

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

const KickCommand &KickInterceptCalculate::getKickCommand() const
{
	return *kickCommand;
}

const KickInterceptPlayer &KickInterceptCalculate::getCheckedInterPlayer(unsigned num) const
{
	return checkedPlayers[num];
}

const Ball &KickInterceptCalculate::getFirstBall() const
{
	return firstBall;
}

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

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

// Setting functions
void KickInterceptCalculate::setValid(bool validFlagArg)
{
	validFlag = validFlagArg;
}


// class KickCalculate
KickCalculate::KickCalculate()
{
	setValid(false);
	setInited(false);

	simulates = NULL;
	simulatesNum = 0;
}

KickCalculate::~KickCalculate()
{
	if (isInited())
		delete [] simulates;
}

void KickCalculate::init()
{
	setInited(true);

	simulatesNum = KICK_CALCULATES_NUM;
	simulates = new KickInterceptCalculate[simulatesNum];
}

void KickCalculate::update(const WorldModel *worldModel)
{
	InterceptCalculate interCalc;
	KickCommand *kickCommand = new KickCommand(AT_KICK_CALCULATE, 100, 0);

	LOG << "KickCalculate::update" << endl;

	setValid(true);

	updateTime = worldModel->getCurTime();

	interCalc.startSession(1, &worldModel->getBody(), NULL);
	interCalc.setShareCycles(1);
//	if (worldModel->getCurCycle() == 82)
//		interCalc.setLogging(true);
	interCalc.updateByWorldModel(worldModel);

	for (unsigned i = 0; i < simulatesNum - KICK_CALCULATES_EXTRA_NUM; i++)
	{
		kickCommand->setPower(((i % KICK_POW_NUM) + 1) * KICK_POW_STEP);
		kickCommand->setDirection(normalizeAngle(
				floor((float)i / KICK_POW_NUM) * KICK_DIR_STEP));

		simulates[i].init(worldModel, kickCommand, interCalc);
	}

	for (unsigned i = 0; i < KICK_CALCULATES_EXTRA_NUM; i++)
	{
		delete kickCommand;
		KickToDirectionVelocity extraKick(AT_KICK_CALCULATE, worldModel->getBody().getBodyDir(),
			0.75 + i * 0.25, worldModel->getBall(), worldModel->getBody());

		if (extraKick.isPossible())
			kickCommand = dynamic_cast<KickCommand *>(extraKick.getCommand());
		else
			kickCommand = NULL;

		simulates[i].init(worldModel, kickCommand, interCalc);
	}

	delete kickCommand;
}

void KickCalculate::getNeighboursByDir(unsigned num,
		unsigned &neighbour1, unsigned &neighbour2) const
{
	float pow = simulates[num].getKickCommand().getPower();
	float dir = simulates[num].getKickCommand().getDirection();

	neighbour1 = NOVALUE;
	neighbour2 = NOVALUE;

	for (unsigned i = 0; i < KICK_CALCULATES_NUM; i++)
	{
		float thisPow = simulates[i].getKickCommand().getPower();
		float thisDir = simulates[i].getKickCommand().getDirection();

		if (pow == thisPow)
		{
		}
		else if (neighbour1 == NOVALUE &&
				getDeltaAngle(thisDir,dir) == KICK_DIR_STEP)
		{
			neighbour1 = i;
			if (neighbour2 != NOVALUE)
				break;
		}
		else if (neighbour2 == NOVALUE &&
				getDeltaAngle(thisDir,dir) == -KICK_DIR_STEP)
		{
			neighbour2 = i;
			if (neighbour1 != NOVALUE)
				break;
		}
	}
}

// Getting functions
bool KickCalculate::isValid() const
{
	return validFlag;
}

bool KickCalculate::isInited() const
{
	return initedFlag;
}

unsigned KickCalculate::getUpdateTime() const
{
	return updateTime;
}

unsigned KickCalculate::getSimulatesNum() const
{
	return simulatesNum;
}

const KickInterceptCalculate &KickCalculate::getSimulate(unsigned num) const
{
	return simulates[num];
}

// Setting functions
void KickCalculate::setInited(bool initedFlagArg)
{
	initedFlag = initedFlagArg;
}

void KickCalculate::setValid(bool validFlagArg)
{
	validFlag = validFlagArg;
}