virtualpass.cpp

mersad源码 03年robocup 季军 可以研究一下大家

/*
 *  Copyright 2002-2004, Mersad Team, Allame 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.
 *
 *  Created by: Ahmad Boorghany
 *  Released on Friday 1 April 2005 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>


using namespace std;


// class VirtualKickInterceptCalculate

VirtualKickInterceptCalculate::~VirtualKickInterceptCalculate()
{
}

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

	firstBall = worldModel->getBall();
	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);

	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, 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.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);

	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, ballVel, interCalc);
	}
}


// class VirtualPass

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

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

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