pass.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 <cassert>

#include <Pass.h>
#include <Basics.h>
#include <Degree.h>
#include <Config.h>
#include <Logger.h>
#include <Defines.h>
#include <BasicKick.h>
#include <SayDecision.h>

#include <AdvancedAgent.h>


#define PW_VERY_BAD -75
#define PW_BAD -30
#define PW_NOTHING -15
#define PW_GOOD 60
#define PW_VERY_GOOD 85


using namespace std;
using namespace Basics;
using namespace Degree;

// class CrossCalculate
CrossCalculate::~CrossCalculate()
{
}

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

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

void CrossCalculate::update(const WorldModel *worldModel)
{
	InterceptCalculate interCalc;
	Command *kickCommand = NULL;

	LOG << "CrossCalculate::update" << endl;

	updateTime = worldModel->getCurTime();

	interCalc.startSession(1, &worldModel->getBody());
//	interCalc.setLogging(true);

	interCalc.setShareCycles(0);

	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.updateByWorldModel(worldModel);

	Vector vector;
	vector.setByPoints(worldModel->getBody().getPos(), CROSS_CENTER_POINT);

	for (unsigned i = 0; i < simulatesNum; i++)
	{
//cout << "Ahmad: Cross pos: " << worldModel->getBody().getPos() + vector << endl;
		kickCommand = FastKickToDir(AT_CROSS_CALCULATE, vector.getDirection() +
									((int)i - CROSS_DIR_NUM / 2.00) * CROSS_DIR_STEP,
									worldModel->getBall(), worldModel->getBody()).getCommand();
//cout << "Ahmad: Cross command: " << kickCommand->toString() << endl;

		simulates[i].init(worldModel,
						  dynamic_cast<KickCommand *>(kickCommand), interCalc);

		delete kickCommand;
	}
}


// class Pass
Pass::Pass(const WorldModel *worldModel, bool dontCreateCrossCalc):
		AdvancedAction(worldModel), dribblePath(worldModel)
{
	logLevel = 0;
	passCommand = NULL;
	loadPassFactors();

	if (!dontCreateCrossCalc)
	{
		crossCalculate = new CrossCalculate();
		crossCalculate->init();
	}
	else
		crossCalculate = NULL;
}

Pass::~Pass()
{
	delete crossCalculate;
	crossCalculate = NULL;
}

float Pass::getValue(const Library &library)
{
	LOG << "Pass::getValue" << endl;

	delete passCommand;
	passCommand = NULL;

	if (worldModel->getPlayMode() == PM_KICK_OFF)
	{
		LOG << "Pass: Our kick off mode." << endl;

		if (worldModel->getCurTime() % 2)
		{
			passCommand = new KickCommand(AT_PASS, 100, -115);
			passPlayer = &worldModel->getFullPlayer(TID_TEAMMATE, 11 - 1);
		}
		else
		{
			passCommand = new KickCommand(AT_PASS, 100, 115);
			passPlayer = &worldModel->getFullPlayer(TID_TEAMMATE, 10 - 1);
		}

		passInterCalc = NULL;
		passModel = PAM_KICK_OFF;
		passValue = AD_NORMAL_VALUE;
		return passValue;
	}

	if (logLevel >= 1)
		loadPassFactors();

	calculateGlobalVars();

	if (crossRate)
		crossCalculate->update(worldModel);

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

	if (worldModel->getHearedSuggestPassTime() == worldModel->getCurTime())
	{
		LOG << "Suggested pass:" << endl
			<< "\tPlayer: " << worldModel->getHearedSuggestPassNum() << endl
			<< "\tWeight: " << worldModel->getHearedSuggestPassWeight() << endl
			<< "\tSpeed: " << worldModel->getHearedSuggestPassSpeed() << endl
			<< "\tDir: " << worldModel->getHearedSuggestPassDir() << endl;

		if (worldModel->getHearedSuggestPassWeight() +
			SUGGEST_REAL_DELTA_WEIGHT > passValue)
		{
			KickToDirectionVelocity basicKick(AT_PASS,
				worldModel->getHearedSuggestPassDir(),
				worldModel->getHearedSuggestPassSpeed(),
				worldModel->getBall(), worldModel->getBody());

			if (basicKick.isPossible())
			{
				LOG << "Suggested pass accepted." << endl;

				passModel = PAM_SUGGESTED;
				passValue = worldModel->getHearedSuggestPassWeight() +
					SUGGEST_REAL_DELTA_WEIGHT;

				passCommand = dynamic_cast<KickCommand *>
					(basicKick.getCommand());
			}
			else
				LOG << "Suggested pass refused: kick is not possible." << endl;
		}
		else
			LOG << "Suggested pass refused: less weight." << endl;
	}

	if (passModel == PAM_SUGGESTED)
	{
		if (worldModel->getHearedSuggestPassNum() != 0)
			passPlayer = &worldModel->getFullPlayer(TID_TEAMMATE,
													worldModel->getHearedSuggestPassNum() - 1);
		else
			passPlayer = &worldModel->getHalfPlayer(TID_TEAMMATE, 0);
	}
	else
	{
		if (passInterCalc == NULL)
		{
			passPlayer = NULL;
			return AD_MIN_VALUE;
		}

		passCommand = new KickCommand(passInterCalc->getKickCommand());
		passPlayer = &passInterCalc->getFastestTmmInterPlayer().getPlayer();
	}

	return passValue;
}

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

	string passModelStr;

	form.sayForm.interceptNum = 0;
	form.sayForm.beforePassSay = true;

	if (passPlayer != NULL)
	{
		switch (passModel)
		{
			case PAM_NONE:
				passModelStr = "None";
				break;
			case PAM_CROSS:
				passModelStr = "Cross";
				break;
			case PAM_OFFENSE:
				passModelStr = "Offense";
				break;
			case PAM_SECURE_BALL:
				passModelStr = "SecureBall";
				break;
			case PAM_BREAK_OFFSIDE:
				passModelStr = "BreakOffside";
				break;
			case PAM_SUGGESTED:
				passModelStr = "Suggested";
				break;
			case PAM_KICK_OFF:
				passModelStr = "KickOff";
				break;

			default:
				assert(0);
		}

		if (passPlayer->getModel() == PLM_FULL)
		{
			form.sayForm.interceptNum = passPlayer->getUniNum();
			LOG << passModelStr << " pass to player: "
				<< passPlayer->getUniNum() << endl;
		}
		else
			LOG << passModelStr << " pass to player: "
				<< "<HalfPlayer>" << endl;
	}
	else
		LOG << "*** There is nobody to pass and Pass is executed ***" << endl;

	if (passCommand)
	{
		command = new KickCommand(*passCommand);
		command->setCreator(AT_PASS);
	}
	else
		command = new EmptyCommand(AT_PASS);

	if (logLevel >= 4)
	{
			// Debuging GoToBallCalculate before simulating ball for next cycle.
		InterceptCalculate interCalc;
		Ball ball = worldModel->getBall();
		ball.simulateByAction(worldModel->getBody(), command);
//		ball.simulateByDynamics(worldModel->getBody());

		interCalc.startSession(1, &worldModel->getBody());
		interCalc.setLogging(true);
		interCalc.updateByWorldModel(worldModel);
		interCalc.setVirtualBall(ball);
		interCalc.run();
	}

}

void Pass::loadPassFactors()
{
	config.add("Pass");
	config["Pass"].setByFile("./Configs/PassFactors.conf");

	// crossFactors
	crossFactors.posDev.minValue = config["Pass"]["PosDeviation"]["MinValue"][0].asFloat();
	crossFactors.posDev.maxValue = config["Pass"]["PosDeviation"]["MaxValue"][0].asFloat();
	crossFactors.posDev.minWeight = config["Pass"]["PosDeviation"]["MinWeight"][0].asFloat();
	crossFactors.posDev.maxWeight = config["Pass"]["PosDeviation"]["MaxWeight"][0].asFloat();

	crossFactors.offense.minValue = config["Pass"]["Offense"]["MinValue"][0].asFloat();
	crossFactors.offense.maxValue = config["Pass"]["Offense"]["MaxValue"][0].asFloat();
	crossFactors.offense.minWeight = config["Pass"]["Offense"]["MinWeight"][0].asFloat();
	crossFactors.offense.maxWeight = config["Pass"]["Offense"]["MaxWeight"][0].asFloat();

	crossFactors.seeInfo.minValue = config["Pass"]["SeeInformation"]["MinValue"][0].asFloat();
	crossFactors.seeInfo.maxValue = config["Pass"]["SeeInformation"]["MaxValue"][0].asFloat();
	crossFactors.seeInfo.minWeight = config["Pass"]["SeeInformation"]["MinWeight"][0].asFloat();
	crossFactors.seeInfo.maxWeight = config["Pass"]["SeeInformation"]["MaxWeight"][0].asFloat();

	crossFactors.ballDist.minValue = config["Pass"]["BallDistance"]["MinValue"][0].asFloat();
	crossFactors.ballDist.maxValue = config["Pass"]["BallDistance"]["MaxValue"][0].asFloat();
	crossFactors.ballDist.minWeight = config["Pass"]["BallDistance"]["MinWeight"][0].asFloat();
	crossFactors.ballDist.maxWeight = config["Pass"]["BallDistance"]["MaxWeight"][0].asFloat();

	crossFactors.dashDist.minValue = config["Pass"]["DashDistance"]["MinValue"][0].asFloat();
	crossFactors.dashDist.maxValue = config["Pass"]["DashDistance"]["MaxValue"][0].asFloat();
	crossFactors.dashDist.minWeight = config["Pass"]["DashDistance"]["MinWeight"][0].asFloat();
	crossFactors.dashDist.maxWeight = config["Pass"]["DashDistance"]["MaxWeight"][0].asFloat();

	crossFactors.breakOffside.minValue = config["Pass"]["BreakOffsideLine"]["MinValue"][0].asFloat();
	crossFactors.breakOffside.maxValue = config["Pass"]["BreakOffsideLine"]["MaxValue"][0].asFloat();
	crossFactors.breakOffside.minWeight = config["Pass"]["BreakOffsideLine"]["MinWeight"][0].asFloat();
	crossFactors.breakOffside.maxWeight = config["Pass"]["BreakOffsideLine"]["MaxWeight"][0].asFloat();

	crossFactors.passedOppNum.minValue = config["Pass"]["PassedOppNum"]["MinValue"][0].asFloat();
	crossFactors.passedOppNum.maxValue = config["Pass"]["PassedOppNum"]["MaxValue"][0].asFloat();
	crossFactors.passedOppNum.minWeight = config["Pass"]["PassedOppNum"]["MinWeight"][0].asFloat();
	crossFactors.passedOppNum.maxWeight = config["Pass"]["PassedOppNum"]["MaxWeight"][0].asFloat();

	crossFactors.statusOppNum.minValue = config["Pass"]["StatusOppNum"]["MinValue"][0].asFloat();
	crossFactors.statusOppNum.maxValue = config["Pass"]["StatusOppNum"]["MaxValue"][0].asFloat();
	crossFactors.statusOppNum.minWeight = config["Pass"]["StatusOppNum"]["MinWeight"][0].asFloat();
	crossFactors.statusOppNum.maxWeight = config["Pass"]["StatusOppNum"]["MaxWeight"][0].asFloat();

	crossFactors.securityDeltaCycle.minValue = config["Pass"]["SecurityDeltaCycle"]["MinValue"][0].asFloat();
	crossFactors.securityDeltaCycle.maxValue = config["Pass"]["SecurityDeltaCycle"]["MaxValue"][0].asFloat();
	crossFactors.securityDeltaCycle.minWeight = config["Pass"]["SecurityDeltaCycle"]["MinWeight"][0].asFloat();
	crossFactors.securityDeltaCycle.maxWeight = config["Pass"]["SecurityDeltaCycle"]["MaxWeight"][0].asFloat();

	crossFactors.statusOppDist.minValue = config["Pass"]["StatusOppDistance"]["MinValue"][0].asFloat();
	crossFactors.statusOppDist.maxValue = config["Pass"]["StatusOppDistance"]["MaxValue"][0].asFloat();
	crossFactors.statusOppDist.minWeight = config["Pass"]["StatusOppDistance"]["MinWeight"][0].asFloat();
	crossFactors.statusOppDist.maxWeight = config["Pass"]["StatusOppDistance"]["MaxWeight"][0].asFloat();

	crossFactors.statusOppDir.minValue = config["Pass"]["StatusOppDirection"]["MinValue"][0].asFloat();