block.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: 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 <Block.h>
#include <cassert>
#include <Degree.h>
#include <BasicDash.h>
#include <Logger.h>

#include <AdvancedAgent.h>

using namespace std;

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

	float minTurnAngle = 20;
	if (!worldModel->getCurInterCalculate().existFastestPlayer())
	{
		LOG << "BLOCK AD_MIN_VALUE 1" << endl;
		return AD_MIN_VALUE;
	}

	blockCommand = NULL;
	float oppDribbleFixedVel = 1;
	
	Vector oppDribbleVector, opptoMeVector, blockAbsVector, 
			ballVelVector, blockPointToMeVector;

	Point oppDribblePoint = Point(-52.5, 0);
	
	if (worldModel->getBall().getPos().getX() > -30)
	{
		oppDribbleFixedVel = .85;
		oppDribblePoint.y = worldModel->getBall().getPos().getY();
	}
	else
		oppDribbleFixedVel = 1.1;
		
	
	oppDribbleVector.setByPoints(worldModel->getBall().getPos(), 
			oppDribblePoint);

	ballVelVector.setAsPolar(oppDribbleFixedVel, 
						oppDribbleVector.getDirection());
	
	opptoMeVector.setByPoints(worldModel->getBall().getPos(), 
			worldModel->getBody().getPos());

	blockInterCalc.startSession(0, NULL, 
			&worldModel->getCurInterCalculate().getFastestPlayer());
//	blockInterCalc.setLogging(true);
//	if (worldModel->getBallStatus() == BS_KICKABLE_OPP)
//	{
	if (worldModel->getBall().getPos().getX() > -35)
	{
		blockInterCalc.setTmmSeeBallDelay(3);
		blockInterCalc.setTmmSlowDashPower(15);
		blockInterCalc.setTmmDirectDashPower(15);
	}
	else
	{
		blockInterCalc.setTmmSeeBallDelay(2);
		blockInterCalc.setTmmSlowDashPower(20);
		blockInterCalc.setTmmDirectDashPower(20);
	}
//	}
	blockInterCalc.addPlayer(worldModel->getBody());
	blockInterCalc.addPlayer(worldModel->getCurInterCalculate().
			getFastestPlayer(), false, true);

	Ball blockBall(worldModel->getBall());

//	if (worldModel->getBallStatus() == BS_KICKABLE_OPP)
//			blockBall.setPos() = worldModel->getCurInterCalculate().
//											getFastestPlayer().getPos();
			
	blockInterCalc.setVirtualBall(blockBall);		
			
	blockInterCalc.setBlockedBallVel(ballVelVector);		
	blockInterCalc.run();
	
 	while (!blockInterCalc.existFastestPlayer() && 
				ballVelVector.getMagnitude() >= 0)
	{
		ballVelVector.setAsPolar(ballVelVector.getMagnitude() - .05, 
								ballVelVector.getDirection());	
		//	blockInterCalc.setLogging(true);
		if (worldModel->getBallStatus() == BS_KICKABLE_OPP &&
			worldModel->getBall().getPos().getX() > -36)
		{
			blockInterCalc.setTmmSeeBallDelay(2);
			blockInterCalc.setTmmSlowDashPower(20);
			blockInterCalc.setTmmDirectDashPower(20);
		}

		blockInterCalc.setVirtualBall(worldModel->getBall());		
		blockInterCalc.setBlockedBallVel(ballVelVector);		
		blockInterCalc.run();
	}
 	
	if (!blockInterCalc.existFastestPlayer())
	{
		blockCommand = NULL;
		LOG << "BLOCK RETURN AD_MIN_VALUE 2 " << endl;
		return AD_MIN_VALUE;
	} 
	
	blockPoint = blockInterCalc.getFastestInterPlayer().getInterPoint();
	
	blockPointToMeVector.setByPoints(blockPoint, 
				worldModel->getBody().getPos());
	
	blockAbsVector.setAsPolar(blockPointToMeVector.getMagnitude(), 
				Degree::getDeltaAngle(oppDribbleVector.getDirection(), 
				blockPointToMeVector.getDirection()));
	float maxBasicDist = 1.5 + blockPointToMeVector.getMagnitude() / 5.00;
	LOG << "worldModel->getCurInterCalculate().getFastestPlayer().getPos() : "
		<< worldModel->getCurInterCalculate().getFastestPlayer().getPos() << endl;
		
	LOG << "maxBasicDist : " << maxBasicDist << endl;

	Vector changedBlockVector;
	Point changedBlockPoint;
	changedBlockVector.setAsPolar(10, oppDribbleVector.getDirection());
	changedBlockPoint.x = worldModel->getBody().getPos().getX() + changedBlockVector.getX();
	changedBlockPoint.y = worldModel->getBody().getPos().getY() + changedBlockVector.getY();
	LOG << "blockPoint : " << blockPoint << endl;
	LOG << "changedBlockPoint : " << changedBlockPoint << endl;
////////////////////////////////////


	if (worldModel->getBody().getPostNum() <= 5)
	{
		if (blockPoint.x >= 0)
			blockPoint.x = 0;
	}
////////////////THISO
/*	if ((worldModel->getBody().getPostNum() <= 5 || 
		worldModel->getBody().getPostNum() == 8) && 
		worldModel->getBall().getPos().getX() > -34 &&
		worldModel->getBall().getPos().getX() < 0)
	{
		float unitStep = 6.5;
		float deffStep = ((int)(worldModel->getBall().getPos().getX() / 
					unitStep) - 1) * unitStep;
		if (blockPoint.x > deffStep)
			blockPoint.x = deffStep;
	}*/
////////////////THISO





	if ((worldModel->getBody().getPostNum() <= 5 || 
		worldModel->getBody().getPostNum() == 8) &&
		worldModel->getCurInterCalculate().existFastestPlayer())
	{
//		float outsideMaxDelY;
//		float insideMaxDelY;
//		float bodyDeltaX = worldModel->getBody().getPos().getX() - blockPoint.x;
//		float bodyDeltaY = worldModel->getBody().getPos().getY() - blockPoint.y;

		Point localHomePoint = library.positioning.getHomePoint(worldModel->getBody().getUniNum());

		float deltaX = library.positioning.getHomePoint(
				worldModel->getBody().getUniNum()).x - blockPoint.x;
	
		float deltaY = library.positioning.getHomePoint(
				worldModel->getBody().getUniNum()).y - blockPoint.y;

		float deltaBodyX = worldModel->getBody().getPos().getX() - blockPoint.x;
		float deltaBodyY = worldModel->getBody().getPos().getY() - blockPoint.y;
	
		
		LOG << "MEISAM 2005 KHOONE : blockPoint , homePoint : " << blockPoint << 
					" " <<  library.positioning.getHomePoint(
				worldModel->getBody().getUniNum()) << endl;
						
		float xDist34 = -4.5;
		float xBodyDist34 = -3.5;
		
		if (worldModel->getBall().getPos().getX() > -30)
		{
			if (library.lastBodyCycleCommand->getCreator() == AT_BLOCK)
				xDist34 = -4.5;
		}
		if (worldModel->getBall().getPos().getX() < -30)
		{
			xDist34 = -2.5;		
			if (library.lastBodyCycleCommand->getCreator() == AT_BLOCK)
				xDist34 = -3.5;
		}

		float xDist25 = -4.8;
		if (worldModel->getBall().getPos().getX() > -30)
		{
			if (library.lastBodyCycleCommand->getCreator() == AT_BLOCK)
				xDist25 = -11;
		}
		if (worldModel->getBall().getPos().getX() < -30)
		{
			xDist25 = -2.5;		
			if (library.lastBodyCycleCommand->getCreator() == AT_BLOCK)
				xDist25 = -4;
		}
		if (worldModel->getBody().getStamina() < 2000)
			xDist25 = -2;
		if (worldModel->getBody().getStamina() < 1700)
			xDist25 = -1;
		
		float bigDelY34, smallDelY34;
		
		if (worldModel->getBody().getPos().getX() > blockPoint.x)
		{
			if (blockPoint.x > -3)
			{
				bigDelY34 = 6;
				smallDelY34 = 4;
			}
			else
			{
				bigDelY34 = 6;
				smallDelY34 = 6;
			}
		}
		else
		{
			if (blockPoint.x > -3)
			{
				bigDelY34 = 6;
				smallDelY34 = 4;
			}
			else
			{
				bigDelY34 = 6;
				smallDelY34 = 6;
			}
		}
		
		LOG << "library.lastBodyCycleCommand->getCreator() : " <<
				library.lastBodyCycleCommand->getCreator() << endl;
		LOG << "AT_BLOCK = " << AT_BLOCK << endl;
		if (library.lastBodyCycleCommand->getCreator() == AT_BLOCK)
		{
			bigDelY34 *= 1.2;
			smallDelY34 *= 1.2;
		}
		
		LOG << "MEISAM : BLOCK : deltaX , deltaY : " << deltaX << " " << 
				deltaY << endl;
		LOG << "MEISAM2005 : BLOCK : deltaBodyX , deltaBodyY : " << deltaBodyX << " " << 
				deltaBodyY << endl;
		LOG << "MEISAM : BLOCK : localHomePoint : " <<  localHomePoint << endl;
		float smallVeto2 = 5, bigVeto2 = 8, alowedDelBodyX = 3;
	
		if (library.lastBodyCycleCommand->getCreator() == AT_BLOCK)
		{
			smallVeto2 = 7;
			bigVeto2 = 10;
			alowedDelBodyX = 4.5;
		}
		

		switch (worldModel->getBody().getPostNum())
		{
			case 2:
				if (deltaY < -5 || (deltaX < xDist25 && blockPoint.x > 
						worldModel->getBody().getPos().getX()))
					return AD_MIN_VALUE;
				break;
			case 5:
				if (deltaY > 5 || (deltaX < xDist25 && blockPoint.x > 
						worldModel->getBody().getPos().getX()))
					return AD_MIN_VALUE;
				break;
			
			case 3:
			case 4:
				if (!(((fabs(deltaY) < bigDelY34 && fabs(worldModel->getBall().getPos().getY()) < 
					fabs(localHomePoint.y)) || 
					(fabs(deltaY) < smallDelY34 && fabs(worldModel->getBall().getPos().getY()) > 
					fabs(localHomePoint.y))) && 
					((deltaX > xDist34 || (deltaX * .5 > xDist34 && deltaBodyX > xBodyDist34)) || 
						blockPoint.x < worldModel->getBody().getPos().getX())))
				{
					LOG << "VETO VETO Block 1 " << endl;
					return AD_MIN_VALUE;
				}
				else if (((worldModel->getBody().getPos().getX() - 
						worldModel->getBall().getPos().getX()) < -smallVeto2 && 
						deltaBodyX < -alowedDelBodyX) || 
						(worldModel->getBody().getPos().getX() - 
						worldModel->getBall().getPos().getX()) < -bigVeto2)
				{
					LOG << "VETO VETO Block 2 " << endl;
					return AD_MIN_VALUE;
				}
					
				break;
			case 8:
				if (worldModel->getBall().getPos().getX() > 5)
				{
					if (!(fabs(deltaY) <= 4 &&
						(fabs(deltaX) <= 2 || 
						blockPoint.x <= worldModel->getBody().getPos().getX())))// || deltaX < -4.5)
						return AD_MIN_VALUE;
					break;
				}
				else if (worldModel->getBall().getPos().getX() > -30)
				{
					LOG << "SALAM Block 1 : Dx,Dy" << deltaX << " " << deltaY << endl;
//
					if (!((fabs(deltaY) <= 4 &&
						(fabs(deltaX) <= 4 || 
						blockPoint.x <= worldModel->getBody().getPos().getX()))
						|| (fabs(deltaY) <= 4 &&
						(deltaX <= 0 || 
						blockPoint.x <= worldModel->getBody().getPos().getX()))))// || deltaX < -4.5)
						return AD_MIN_VALUE;
					
					break;
//
				}
				else
				{
					if (!(fabs(deltaY) <= 4 && 
						(fabs(deltaX) <= 4 || 
						blockPoint.x <= worldModel->getBody().getPos().getX())))// || deltaX < -4.5)
						return AD_MIN_VALUE;
					break;
				}
				break;
		}
	}
////////////////////////////////////

	if (worldModel->getBody().getPostNum() == 6 ||
		worldModel->getBody().getPostNum() == 7)
		if (blockPoint.x < worldModel->getTmmOffsideLine() &&
			worldModel->getBody().getPos().getX() != 
			worldModel->getTmmOffsideLine())
		{
			LOG << "AKHARIN TOF" << endl;
			blockPoint.x = worldModel->getTmmOffsideLine();
//			return AD_MIN_VALUE;
		}	
		
	LOG << "BLOCK fabs(blockAbsVector.getDirection() ( > 110) : " << 
			fabs(blockAbsVector.getDirection()) << endl;

	LOG << "BLOCK fabs(blockAbsVector.getY()) : ( < 8 )" <<
			fabs(blockAbsVector.getY()) << endl; 

	float maxYBlockDist = 5;
	
	maxYBlockDist += (fabs(blockAbsVector.getDirection()) - 130) / 25.00;
	maxYBlockDist = min(maxYBlockDist, float(10));
	
	if (fabs(blockAbsVector.getDirection()) > 155 && 
		fabs(blockAbsVector.getY()) < maxYBlockDist && 
			worldModel->getBall().getPos().getX() > -35)
	{
//		blockPoint = changedBlockPoint;
//		minTurnAngle = 16;		
//		LOG << "blockPoint changed to changedBlockPoint ;)" << endl;
	}

	float distToBlockPoint = blockPointToMeVector.getMagnitude();
	LOG << "------- -- MEISAM 2005 Block New method -- ----------" << endl;
	LOG << "distance to blockPoint : " << distToBlockPoint << endl;
	LOG << "-----------------------------------------------------" << endl;

	float minDistAction = 1;
	
	
	float bigDist = 2.8, smallDist = 1.8;
	float bigAngle = 60, smallAngle = 45;
	
	if (((worldModel->getBody().getPostNum() == 3 && 
			blockPoint.y < worldModel->getBody().getPos().getY()) ||
			(worldModel->getBody().getPostNum() == 4 && 
			blockPoint.y > worldModel->getBody().getPos().getY()))) 
	{
		smallDist = 2.4;
	}		
			
	
	
	if (distToBlockPoint < bigDist)
	{
		if ((fabs(blockAbsVector.getDirection()) < smallAngle ||
			(fabs(blockAbsVector.getDirection()) < bigAngle && 
			distToBlockPoint < smallDist)) && 
			worldModel->getBallStatus() == BS_KICKABLE_OPP &&
			!((worldModel->getBody().getPostNum() <= 5) && worldModel->
				getCurInterCalculate().getFastestPlayer().getPos().getX() > 0))

		{
			LOG << "Meisam2005 blockPoint is changed to enemy position " << endl;
			blockPoint = worldModel->getCurInterCalculate().
			getFastestPlayer().getPos();
			minDistAction = .4;
			LOG << "Meisam2005 changed blockPoint : " << blockPoint << endl;
		}
	}

	LOG << "latest blockPoint : " <<  blockPoint << endl;
	
	
	blockCommand = PreciseGotoPoint(AT_BLOCK, blockPoint, minDistAction,
			worldModel->getBody(), 0, minTurnAngle).getCommand();
	if (blockCommand == NULL)
		blockCommand = new EmptyCommand(AT_BLOCK);
	return AD_ALWAYS_RUN_VALUE;
}

Block::Block(const WorldModel *worldModel): AdvancedAction(worldModel)
{
}

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

	command = blockCommand;
}

Block::~Block()
{
}