virtualpass.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 <iostream>

#include <Pass.h>
#include <Logger.h>
#include <Degree.h>
#include <Command.h>
#include <WorldModel.h>
#include <VirtualPass.h>

#include <AdvancedAgent.h>


using namespace std;


// class VirtualKickInterceptCalculate

VirtualKickInterceptCalculate::~VirtualKickInterceptCalculate()
{
}

void VirtualKickInterceptCalculate::init(const WorldModel *worldModel,
		const Ball &nextBall, const Vector &ballVel,
		InterceptCalculate &interCalc)
{
	delete kickCommand;
	kickCommand = new KickCommand(AT_NONE, 0, 0);

	firstBall = nextBall;
	firstBall.setVel() = ballVel;

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


// class VirtualKickCalculate

VirtualKickCalculate::~VirtualKickCalculate()
{
}

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

	simulatesNum = VIRTUAL_KICK_CALCULATES_NUM;
	simulates = new VirtualKickInterceptCalculate[simulatesNum];
}

void VirtualKickCalculate::update(const WorldModel *worldModel,
		const Player &kickPlayer)
{
	Vector ballVel;
	InterceptCalculate interCalc;

	LOG << "VirtualKickCalculate::update" << endl;

	updateTime = worldModel->getCurTime();

	interCalc.startSession(1, &kickPlayer);
//	interCalc.setLogging(true);

/*	interCalc.setShareCycles(1);

	interCalc.setTmmPosDevRate(-1);
	interCalc.setTmmSlowDashPower(0);
	interCalc.setTmmFastDashPower(90);
	interCalc.setTmmDirectDashPower(0);
	interCalc.setTmmSeeBallDelay(3);

	interCalc.setOppPosDevRate(1);
	interCalc.setOppSlowDashPower(40);
	interCalc.setOppFastDashPower(100);
	interCalc.setOppDirectDashPower(90);
	interCalc.setOppGoalieDirectDashPower(100);
	interCalc.setOppSeeBallDelay(0);
	interCalc.setOppGoalieSeeBallDelay(0);*/

	interCalc.updateByWorldModel(worldModel, true); // We do not need kicker.

//	Player nextPlayer(kickPlayer);
//	nextPlayer.simulateByDynamics(worldModel->getBody());
//	interCalc.addPlayer(nextPlayer, true);

	Ball nextBall(worldModel->getBall());
	nextBall.simulateByDynamics(worldModel->getBody());

	for (unsigned i = 0; i < simulatesNum; i++)
	{
		ballVel.setAsPolar((i % VIRTUAL_KICK_VEL_NUM) * 0.5 + 1.00,
				(unsigned)(i / 4.00) * VIRTUAL_KICK_DIR_STEP);

		VirtualKickInterceptCalculate *virtualKickInterCalc =
				dynamic_cast<VirtualKickInterceptCalculate *>(&simulates[i]);
		virtualKickInterCalc->init(worldModel, nextBall, ballVel, interCalc);
	}
}


// class VirtualCrossCaculate

VirtualCrossCalculate::~VirtualCrossCalculate()
{
}

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

	simulatesNum = CROSS_CALCULATES_NUM;
	simulates = new VirtualKickInterceptCalculate[simulatesNum];
}

void VirtualCrossCalculate::update(const WorldModel *worldModel,
		const Player &kickPlayer)
{
	InterceptCalculate interCalc;
	VirtualKickInterceptCalculate *virtualKickInterCalc;

	LOG << "VirtualCrossCalculate::update" << endl;

	updateTime = worldModel->getCurTime();

	interCalc.startSession(1, &kickPlayer);
//	interCalc.setLogging(true);

    interCalc.setShareCycles(1);

    interCalc.setKickerSeeBallDelay(1);

    interCalc.setTmmPosDevRate(-0.3);
    interCalc.setTmmSlowDashPower(0);
    interCalc.setTmmFastDashPower(100);
    interCalc.setTmmDirectDashPower(0);
    interCalc.setTmmSeeBallDelay(1);

    interCalc.setOppPosDevRate(0.5);
    interCalc.setOppSlowDashPower(10);
    interCalc.setOppFastDashPower(100);
    interCalc.setOppDirectDashPower(60);
    interCalc.setOppGoalieDirectDashPower(100);
    interCalc.setOppSeeBallDelay(1);
    interCalc.setOppGoalieSeeBallDelay(1);

/*	interCalc.setShareCycles(1); << previous

	interCalc.setTmmPosDevRate(-0.5);
	interCalc.setTmmSlowDashPower(0);
	interCalc.setTmmFastDashPower(100);
	interCalc.setTmmDirectDashPower(0);
	interCalc.setTmmSeeBallDelay(2);

	interCalc.setOppPosDevRate(0.85);
	interCalc.setOppSlowDashPower(30);
	interCalc.setOppFastDashPower(100);
	interCalc.setOppDirectDashPower(80);
	interCalc.setOppGoalieDirectDashPower(100);
	interCalc.setOppSeeBallDelay(2);
	interCalc.setOppGoalieSeeBallDelay(0);*/

	interCalc.updateByWorldModel(worldModel, true); // We do not need kicker.

//	Player nextPlayer(kickPlayer);
//	nextPlayer.simulateByDynamics(worldModel->getBody());
//	interCalc.addPlayer(nextPlayer, true);

	Ball nextBall(worldModel->getBall());
	nextBall.simulateByDynamics(worldModel->getBody());

	Vector orgVector;
	orgVector.setByPoints(kickPlayer.getPos(), CROSS_CENTER_POINT);

	for (unsigned i = 0; i < simulatesNum; i++)
	{
		Vector ballVel(orgVector);
		ballVel.setAsPolar(2.6, ballVel.getDirection() +
				((int)i - CROSS_DIR_NUM / 2.00) * CROSS_DIR_STEP);

		virtualKickInterCalc =
				dynamic_cast<VirtualKickInterceptCalculate *>(&simulates[i]);
		virtualKickInterCalc->init(worldModel, nextBall, ballVel, interCalc);
	}
}


// class VirtualPass

VirtualPass::VirtualPass(const WorldModel *worldModel):
		Pass(worldModel, true)
{
	crossCalculate = new VirtualCrossCalculate();

	VirtualCrossCalculate *virtualCrossCalc =
			dynamic_cast<VirtualCrossCalculate *>(crossCalculate);
	virtualCrossCalc->init();

	virtualKickCalc.init();
	setCurKickCalculate(&virtualKickCalc);

	lastUpdate = 0;
}

float VirtualPass::getValue(const Player &kickPlayer)
{
	LOG << "VirtualPass::getValue" << endl;

	if (logLevel >= 1)
		loadPassFactors();

	calculateGlobalVars();

	if (crossRate)
	{
		VirtualCrossCalculate *virtualCrossCalc =
				dynamic_cast<VirtualCrossCalculate *>(crossCalculate);
		virtualCrossCalc->update(worldModel, kickPlayer);
	}

	resetValues();
	fillValues();
	fillMaxValues();
	passValue = getTheBestPass(passInterCalc);

	if (passInterCalc == NULL)
	{
		passPlayer = NULL;
		return AD_MIN_VALUE;
	}

	passPlayer = &passInterCalc->getFastestTmmInterPlayer().getPlayer();
	return passValue;
}

void VirtualPass::manager(Form &form, const Library &library)
{
	LOG << "VirtualPass::manager" << endl;

	form.headForm.tnMode = TNM_LOOK_NORMALLY_TO_BALL;
	form.sayForm.attentionNum = worldModel->getHearedSender(); // Maybe useless.

	if (worldModel->getTimer().now() > ZERO_QUICK_LEVEL_MS ||
		worldModel->getCurTime() - worldModel->getBall().getSeeTime() > 2)
	{
		if (lastUpdate == worldModel->getCurTime()) // I have once updated in this cycle.
		{
			LOG << "\tRecovering say form." << endl;

			form.sayForm.suggestPassSay = true;
			form.sayForm.passDir = getPassInterCalc()->
					getFirstBall().getVel().getDirection();
			form.sayForm.passSpeed = getPassInterCalc()->
					getFirstBall().getVel().getMagnitude();
			form.sayForm.passWeight = getPassValue();
			form.sayForm.passPlayerNum = getPassPlayer()->getUniNum();
		}
		else
			LOG << "\tNot enough time or information." << endl;

		return;
	}

	const Player &kickPlayer = worldModel->getNearestTmmToBall();

	virtualKickCalc.update(worldModel, kickPlayer);
	float value = getValue(kickPlayer);

	if (value <= -50 || value == AD_MIN_VALUE)
	{
		LOG << "\tThere is no good pass." << endl;
		return;
	}

	lastUpdate = worldModel->getCurTime();

	form.sayForm.suggestPassSay = true;
	form.sayForm.passDir = getPassInterCalc()->
			getFirstBall().getVel().getDirection();
	form.sayForm.passSpeed = getPassInterCalc()->
			getFirstBall().getVel().getMagnitude();
	form.sayForm.passWeight = value;
	form.sayForm.passPlayerNum = getPassPlayer()->getUniNum();

	LOG << "\tCalculated virtual pass:" << endl
		<< "\t\tPlayer: " << getPassPlayer()->getTeamId()
		<< " " << getPassPlayer()->getUniNum() << endl
		<< "\t\tWeight: " << getPassValue() << endl
		<< "\t\tModel: " << getPassModel() << endl
		<< "\t\tDir: " << form.sayForm.passDir << endl
		<< "\t\tSpeed: " << form.sayForm.passSpeed << endl;
}