clear.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: Mohammad Salehe
 *  and is modified by: Meisam Vosoughpour
 *
 *  Released on Monday 1 August 2005, 10 Mordad 1384 by Mersad RoboCup Team.
 *  For more information please read README file.
*/

#include <cmath>

#include <Clear.h>
#include <Basics.h>
#include <Logger.h>
#include <BasicKick.h>
#include <SayDecision.h>

#include <AdvancedAgent.h>

using namespace std;

#define CLEAR_TO_PLAYER_DELTA_X 8

#define CLEAR_LOG1

// class Clear
Clear::Clear(const WorldModel *worldModel):
		AdvancedAction(worldModel)
{
}

void Clear::execute(Form &form, const Library &library)
{
	LOG << "Clear::execute" << endl;
	command = clearCommand;

	form.sayForm.beforePassSay = true;
	form.sayForm.interceptNum = twoKickableInterceptNum;
}

float Clear::getValue(const Library &library)
{
	Point kickPoint;
	Vector goalVector;
	int i;
	
	twoKickableInterceptNum = 0;

	float defaultClearWeight = 60;
	LOG << "Clear::getValue" << endl;

	if (!worldModel->isBallKickable())
		return AD_MIN_VALUE;

	if (worldModel->getBallStatus() == BS_KICKABLE_OPP ||
		worldModel->getBallStatus() == BS_KICKABLE_BODY_OPP)
	{
		if (worldModel->getBall().getDistance(Point(52.5, 0)) < 16)
		{
#ifdef CLEAR_LOG1
	LOG << "Clear::TwoKickable model 1" << endl;
#endif
			bool up;
			const Player *player = worldModel->getOppGoalie();
			if (player == NULL)
			{
				if (worldModel->getBall().getPos().getY() > 0)
					up = true;
				else
					up = false;
			}
			else if (player->getPos().getY() > 0)
				up = false;
			else
				up = true;

			if (up)
			{
				Point gccGhat(52.5, 5.5);
				clearCommand = FastKickToPoint(AT_CLEAR, gccGhat,
					worldModel->getBall(), worldModel->getBody()).getCommand();
			}
			else
			{
				Point gccGhat(52.5, -5.5);
				clearCommand = FastKickToPoint(AT_CLEAR, gccGhat,
					worldModel->getBall(), worldModel->getBody()).getCommand();
			}
		}
		else
		{
#ifdef CLEAR_LOG1
	LOG << "Clear::TwoKickable model 2" << endl;
#endif
			bool up;
			const Player *player = worldModel->getOppGoalie();
			Point clearPoints[20];
			int clearPointsNum = 0;
			unsigned clearPlayers[20];
			float clearWeights[20];
			float teammateDistance;
			float distanceWeight, offenseWeight;
			float oppBallRate;
			float oppBallRateMin;

			float maxWeight;
			int maxPointNum;

			oppBallRateMin = 100;
			
			for (i = 0; i < FULL_PLAYERS_NUM; i++)
				if (worldModel->getFullPlayer(TID_OPPONENT, i).isValid())
				{
					oppBallRate = (worldModel->getFullPlayer(TID_OPPONENT, i).
						getDistance(worldModel->getBall()) - worldModel->
						getFullPlayer(TID_OPPONENT, i).getSize() - 
						worldModel->getServerParam()["ball_size"].asFloat()) /
						worldModel->getFullPlayer(TID_OPPONENT, i).getKickableMargin();
					if (oppBallRate <= 1)
					{
						if (oppBallRate < oppBallRateMin)
							oppBallRateMin = oppBallRate;
					}
				}

			for (i = 0; i < HALF_PLAYERS_NUM; i++)
				if (worldModel->getHalfPlayer(TID_OPPONENT, i).isValid())
				{
					oppBallRate = (worldModel->getHalfPlayer(TID_OPPONENT, i).
						getDistance(worldModel->getBall()) - worldModel->
						getHalfPlayer(TID_OPPONENT, i).getSize() - 
						worldModel->getServerParam()["ball_size"].asFloat()) /
						worldModel->getHalfPlayer(TID_OPPONENT, i).getKickableMargin();
					if (oppBallRate <= 1)
					{
						if (oppBallRate < oppBallRateMin)
							oppBallRateMin = oppBallRate;
					}
				}
			
			if (oppBallRateMin > 10)
				oppBallRateMin = 0.1;
			else
				oppBallRateMin = 1 - oppBallRateMin;

#ifdef CLEAR_LOG1
	LOG << "Clear:oppBallRateMin(multiplier)= " << oppBallRateMin << endl;
#endif
					
			for (i = 0; i < FULL_PLAYERS_NUM; i++)
				if (worldModel->getFullPlayer(TID_TEAMMATE, i).isValid())
				{
					if (i + 1 == GOALIE_UNIFORM_NUM)
						continue;
					clearPoints[clearPointsNum] = worldModel->getFullPlayer(TID_TEAMMATE, i).
						getPos();
					clearPoints[clearPointsNum].x += CLEAR_TO_PLAYER_DELTA_X * oppBallRateMin;
					clearPlayers[clearPointsNum] = i + 1;
					teammateDistance = worldModel->getFullPlayer(TID_TEAMMATE, i).
						getBodyVec().getMagnitude();
					if (teammateDistance < 2)
						distanceWeight = 10;
					else if (teammateDistance >= 2 && teammateDistance < 20)
						distanceWeight = Basics::reRate(teammateDistance,
								2, 20, 10, 100);
					else
						distanceWeight = 9;
					offenseWeight = Basics::reRate(worldModel->getFullPlayer(TID_TEAMMATE, i).
						getPos().getX() - worldModel->getBody().getPos().getX(), -10, 18,
						0, 100);
					clearWeights[clearPointsNum] = distanceWeight * 0.5 + offenseWeight * 1.1;
#ifdef CLEAR_LOG1
	LOG << "Clear:addPlayer " << i + 1 << " weight=" <<
		clearWeights[clearPointsNum] << " dw,ow=" << distanceWeight << " " <<
		offenseWeight << endl;
#endif
					if (!FastKickToPoint(AT_CLEAR, clearPoints[clearPointsNum],
						worldModel->getBall(), worldModel->getBody()).isPossible())
					{
#ifdef CLEAR_LOG1
	LOG << "Clear:not possible " << endl; 
#endif
						clearWeights[clearPointsNum] = AD_MIN_VALUE;
					}
					clearPointsNum++;
				}

			// Clear to opponent goal
			if (worldModel->getBall().getDistance(Point(52.5, 0)) < 16)
			{
				if (player == NULL)
				{
					if (worldModel->getBall().getPos().getY() > 0)
						up = true;
					else
						up = false;
				}
				else if (player->getPos().getY() > 0)
					up = false;
				else
					up = true;

				if (up)
				{
					clearPoints[clearPointsNum] = Point(52.5, 10);
				}
				else
				{
					clearPoints[clearPointsNum] = Point(52.5, -10);
				}
				clearPlayers[clearPointsNum] = 0;
				clearWeights[clearPointsNum] = 90 + (worldModel->getBody().getPos().getX() - 20);
#ifdef CLEAR_LOG1
	LOG << "Clear:addGoal " << (up ? "up" : "down") << " weight=" <<
#endif
				clearWeights[clearPointsNum] << endl;
				if (!FastKickToPoint(AT_CLEAR, clearPoints[clearPointsNum],
					worldModel->getBall(), worldModel->getBody()).isPossible())
				{
#ifdef CLEAR_LOG1
	LOG << "Clear:not possible " << endl; 
#endif
					clearWeights[clearPointsNum] = AD_MIN_VALUE;
				}
				clearPointsNum++;
			}
			
			clearPoints[clearPointsNum] = Point(52.5, worldModel->getBody().getPos().getX());
			clearPlayers[clearPointsNum] = 0;
			clearWeights[clearPointsNum] = 1;
#ifdef CLEAR_LOG1
	LOG << "Clear:addDummy " << " weight=" << clearWeights[clearPointsNum] << endl;
#endif
			if (!FastKickToPoint(AT_CLEAR, clearPoints[clearPointsNum],
				worldModel->getBall(), worldModel->getBody()).isPossible())
			{
#ifdef CLEAR_LOG1
	LOG << "Clear:not possible " << endl; 
#endif
				clearWeights[clearPointsNum] = AD_MIN_VALUE;
			}
			clearPointsNum++;
		
			maxPointNum = 0;
			maxWeight = -0xFFFF * 10;

			for (i = 0; i < clearPointsNum; i++)
				if (clearWeights[i] > maxWeight)
				{
					maxWeight = clearWeights[i];
					maxPointNum = i;
				}

#ifdef CLEAR_LOG1
	LOG << "Clear::selected =" << maxPointNum << " " << clearPoints[maxPointNum] << endl;
	LOG << "Clear::selected player=" << clearPlayers[maxPointNum] << endl;
#endif
			if (maxWeight <= AD_MIN_VALUE)
			{
#ifdef CLEAR_LOG1
	LOG << "Clear::all not possible =" << endl;
#endif
				if (worldModel->getBody().getPos().getY() >= 0)
					clearCommand = new KickCommand(AT_CLEAR, 100, 50);
				else
					clearCommand = new KickCommand(AT_CLEAR, 100, -50);
			}
			else
			{	
				clearCommand = FastKickToPoint(AT_CLEAR, clearPoints[maxPointNum],
					worldModel->getBall(), worldModel->getBody()).getCommand();
				twoKickableInterceptNum = clearPlayers[maxPointNum];
			}
		}

		return AD_ALWAYS_RUN_VALUE;