player.cpp

2006年世界杯足球赛2D仿真组第16名的源代码。在此代码上随便改改

/*
 *  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 <cassert>

#include <Body.h>
#include <Config.h>
#include <Logger.h>
#include <Player.h>
#include <Degree.h>
#include <Basics.h>
#include <Defines.h>
#include <SExpression.h>
#include <PossiblePoints.h>


using namespace std;

Player::Player(PlayerModel model) : model(model)
{
	goalieFlag = false;
	tacklingFlag = false;
	pointingDir = 0;
	bodyDir = 0;
	headDir = 0;
	uniNum = 0;
	postNum = 0;
	type = 0;
	teamId = TID_TEAMMATE;

	relativePointingDir = 0;
	relativeBodyDir = 0;
	relativeHeadDir = 0;

	lastAPVRTime = 0;

	dashExpires = 0;
}

Player::~Player()
{
}

void Player::parse(TeamId teamIdArg, unsigned uniNumArg, bool isGoalie,
		const SExpression &exp, unsigned curTime)
{
	SExpAtomic *at;

	tacklingFlag = false;
	relativeBodyDir = -NOVALUE;
	relativeHeadDir = -NOVALUE;
	relativePointingDir = -NOVALUE;

	Object::parse(exp, curTime);

	goalieFlag = isGoalie;
	setUniNum(uniNumArg);
	teamId = teamIdArg;

	if (teamId == TID_UNKNOWN)
		model = PLM_QUARTER;
	else if (uniNum == 0)
		model = PLM_HALF;
	else
		model = PLM_FULL;

	unsigned decreaseNum = 0;
	at = dynamic_cast<SExpAtomic *>(exp[exp.size() - 1]);
	if (at->toString() == "t")
		decreaseNum = 1;

	if (exp.size() - decreaseNum > 6)
	{
		at = dynamic_cast<SExpAtomic *>(exp[5]);
		assert(at);
		relativeBodyDir = at->asFloat();

		at = dynamic_cast<SExpAtomic *>(exp[6]);
		assert(at);
		relativeHeadDir = at->asFloat();
	}

	if (model != PLM_QUARTER)
	{
		at = dynamic_cast<SExpAtomic *>(exp[exp.size() - 1]);
		assert(at);
		if (at->toString() == "t")
			tacklingFlag = true;
	}

	if ((exp.size() - decreaseNum) % 2 == 0) // see format is very very poor in this case.
	{
		if (tacklingFlag)
			at = dynamic_cast<SExpAtomic *>(exp[exp.size() - 2]);
		else
			at = dynamic_cast<SExpAtomic *>(exp[exp.size() - 1]);
		assert(at);
		relativePointingDir = at->asFloat();
	}

	relativeBodyDir *= -1;
	relativeHeadDir *= -1;
	relativePointingDir *= -1;
}

void Player::setServerParamVars(const Param &serverParam)
{
	Object::setServerParamVars(serverParam);

	accelMax = serverParam["player_accel_max"].asFloat();
	decay = serverParam["player_decay"].asFloat();
	rand = serverParam["player_rand"].asFloat();
	size = serverParam["player_size"].asFloat();
	speedMax = serverParam["player_speed_max"].asFloat();

	staminaMax = serverParam["stamina_max"].asFloat();
	effortDecThr = serverParam["effort_dec_thr"].asFloat();
	recoverDecThr = serverParam["recover_dec_thr"].asFloat();
	maxNeckAng = serverParam["maxneckang"].asFloat();
	minNeckAng = serverParam["minneckang"].asFloat();
	maxNeckMoment = serverParam["maxneckmoment"].asFloat();
	minNeckMoment = serverParam["minneckmoment"].asFloat();
	catchableAreaL = serverParam["catchable_area_l"].asFloat();
	catchableAreaW = serverParam["catchable_area_w"].asFloat();
}

void Player::update(const Body &body, PlayMode playMode)
{
	position = possiblePoints.calculatePlayerPosition(*this, body,
			posDeviation, quantizeStep);
	validPosDeviation = posDeviation;

	absVector.setByPoints(body.getPos(), position);
	bodyVector = absVector;
	bodyVector.rotate(-body.getBodyDir());
	headVector = absVector;
	headVector.rotate(-body.getHeadDir());

	if (relativeBodyDir != NOVALUE)
	{
		bodyDir = Degree::normalizeAngle(body.getHeadDir() + relativeBodyDir);
		headDir = Degree::normalizeAngle(body.getHeadDir() + relativeHeadDir);
	}

	if (seeDistChange != NOVALUE)
	{
		velocity.setByDistDirChange(headVector, seeDistChange, seeDirChange);
		velocity.rotate(body.getHeadDir());
		velocity += body.getVel();
	}

	if (relativePointingDir != NOVALUE)
		pointingDir = Degree::normalizeAngle(
				body.getHeadDir() + relativePointingDir);
	else
		pointingDir = NOVALUE;

	float maxSenseStamina;
	if (playMode == PM_PLAY_ON)
		maxSenseStamina = 2500;
	else
		maxSenseStamina = 3850;

	if (pointingDir != NOVALUE)
		stamina = Basics::reRate(Degree::absoluteAngle(pointingDir),
				0, 270, 1000, maxSenseStamina, RRM_DIRECT);
	else
		stamina = staminaMax;

	executeAPVR(body);
	executeAPDR(body);

	if (seeTime == velSeeTime && velocity.getMagnitude() > 0.2)
	{
		LOG << "APMR: started for player " << teamId << " " << uniNum
			<< "." << endl;
		dashExpires = 2;
	}
}

void Player::simulateByDynamics(const Body &body)
{
	if (dashExpires > 0 && bodyDir != NOVALUE)
	{
		LOG << "APMR: accelerated for player " << teamId << " " << uniNum
			<< "." << endl;

		Vector accel;
		accel.setAsPolar(0.6, bodyDir);

		velocity += accel;
		if (velocity.getMagnitude() > getSpeedMax())
			velocity.setAsPolar(getSpeedMax(), velocity.getDirection());
	}

	position += velocity;
	velocity *= decay;

	posDeviation += 1;
	if (posDeviation > MAX_POS_DEV)
		posDeviation = MAX_POS_DEV;

	validPosDeviation += 1;
	if (validPosDeviation > MAX_POS_DEV)
		validPosDeviation = MAX_POS_DEV;

	velDeviation += 0.02;
	if (velDeviation > MAX_VEL_DEV)
		velDeviation = MAX_VEL_DEV;

	absVector.setByPoints(body.getPos(), position);
	bodyVector = absVector;
	bodyVector.rotate(-body.getBodyDir());
	headVector = absVector;
	headVector.rotate(-body.getHeadDir());

//	bodyDir = headDir = NOVALUE;

	if (dashExpires > 0)
		dashExpires--;
}

void Player::virtualUpdate(const Body &body)
{
	position = body.getPos() + absVector;
}

void Player::setByAnotherPlayer(const Player &player, const Body &body)
{
	// Object vars
	posDeviation = player.getPosDeviation();
	validPosDeviation = player.getValidPosDeviation();
	velDeviation = player.getVelDeviation();
	seeDistance = player.getSeeDistance();
	seeDirection = player.getSeeDirection();
	seeDistChange = player.getSeeDistChange();
	seeDirChange = player.getSeeDirChange();
	seeTime = player.getSeeTime();
	velSeeTime = player.getVelSeeTime();

	position = player.getPos();
	velocity = player.getVel();
	absVector = player.getAbsVec();
	bodyVector = player.getBodyVec();
	headVector = player.getHeadVec();

	// Player vars
	goalieFlag = isGoalie() | player.isGoalie();
	tacklingFlag = player.isTackling();
	stamina = player.getStamina();
	bodyDir = player.getBodyDir();
	headDir = player.getHeadDir();
	pointingDir = player.getPointingDir();
	relativeBodyDir = player.getRelativeBodyDir();
	relativeHeadDir = player.getRelativeHeadDir();
	relativePointingDir = player.getRelativePointingDir();

	dashExpires = player.getDashExpires();

	// last* variables do not be copied.

	if (model == PLM_FULL && player.getModel() == PLM_FULL)
	{
		setUniNum(player.getUniNum());
		type = player.getType();

		staminaIncMax = player.getStaminaIncMax();
		inertiaMoment = player.getInertiaMoment();
		dashPowerRate = player.getDashPowerRate();
		kickableMargin = player.getKickableMargin();
		kickRand = player.getKickRand();
		extraStamina = player.getExtraStamina();
		effortMax = player.getEffortMax();
		effortMin = player.getEffortMin();
	}

	if (model >= PLM_HALF && player.getModel() >= PLM_HALF)
		teamId = player.getTeamId();

	// some update functions
	executeAPVR(body);
	executeAPDR(body);
}

bool Player::isBody() const
{
	if (dynamic_cast<const Body *>(this))
		return true;
	return false;
}

bool Player::isAlive() const
{
	if (model != PLM_FULL)
		return isValid();

	if (validPosDeviation < PLAYER_ALIVE_POS_DEV)
		return true;
	return false;
}

bool Player::isValid() const
{
	if (validPosDeviation < PLAYER_VALID_POS_DEV)
		return true;
	return false;
}

void Player::executeAPVR(const Body &body)
{
	// Advance Player Velocity Recognizer (APVR)
	if (model == PLM_FULL && seeDistChange == NOVALUE &&
		absVector.getMagnitude() < APVR_RADIUS &&
		body.getCollisionStatus() != TA_YES && lastAPVRTime == seeTime - 1)
	{
		Vector lastBodyVel(body.getVel());
		lastBodyVel /= body.getDecay();

		Vector virtualVel(absVector - lastAPVRPosition + lastBodyVel);
		virtualVel *= getDecay();

		velocity = virtualVel;
		velSeeTime = seeTime; // it must be in Parsing but it is an exeption.

		LOG << "APVR: executed for player " << teamId << " "
			<< uniNum << "." << endl;
	}

	if (absVector.getMagnitude() < APVR_RADIUS)
	{
		lastAPVRPosition = absVector;
		lastAPVRTime = seeTime;
	}
	else
		lastAPVRTime = 0;
}

void Player::executeAPDR(const Body &body)
{
	// Advanced Player Direction Recognizer (APDR)
	if (model == PLM_FULL && velSeeTime == seeTime &&
		lastAPDRTime == seeTime - 1)
	{
		Vector Accelerate(velocity);
		Accelerate /= getDecay();
		Accelerate -= lastAPDRVelocity;

		if (Accelerate.getMagnitude() > 0.15)
		{
			bodyDir = Accelerate.getDirection();
			LOG << "APDR: executed for player " << teamId << " "
				<< uniNum << "." << endl;
		}
	}

	if (velSeeTime == seeTime)
	{
		lastAPDRVelocity = velocity;
		lastAPDRTime = seeTime;
	}
	else
		lastAPDRTime = 0;
}

bool Player::canBodySee(const Vector &playerPos, float viewAngle,
		float visibleDist) const
{
	float farLength;

	if (model == PLM_FULL)
		farLength = UNUM_FAR_LENGTH;
	else if (model == PLM_HALF)
		farLength = TEAM_FAR_LENGTH;
	else
		farLength = 0xFFFF;

	if (absVector.getMagnitude() + 0.75 * posDeviation < visibleDist)
		return true;

	if (fabs(headVector.getDirection()) +
		Degree::arcTan(0.75 * posDeviation / absVector.getMagnitude()) <
				viewAngle &&
		absVector.getMagnitude() + 0.75 * posDeviation < farLength)
		return true;

	return false;
}

unsigned Player::uniNumToPostNum(unsigned uniNum)
{
	switch (uniNum)
	{
	case 2:
		return 11;
	case 3:
		return 9;
	case 4: