player.c

机器足球2D比赛程序 对trlen_base_2002的改进

		soc = turnBodyToPoint(posPenalty);
	else if (soc.isIllegal())
		soc = moveToPos(pos, 10);
	ACT->putCommandInQueue(soc);
	if (WM->getCurrentTime() - WM->getTimeLastSeen(OBJECT_BALL) > 6)
		ACT->putCommandInQueue(turnNeckToPoint(posPenalty, soc));
	else
		ACT->putCommandInQueue(turnNeckToObject(OBJECT_BALL, soc));

	pmPrev = WM->getPlayMode();
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//                                                  Orit                                                         //
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/*!根据当前的场上状态确定比赛的阵型。
 * 
 */
void Player::formationDecision()
{
	formations->setFormation(FT_433_OFFENSIVE);
	/*
	   VecPosition posBall = WM->getBallPos ();

	   if (posBall.getX()<0){
	   if (WM->isBallInOurPossesion ()) 
	   formations->setFormation( FT_433_OFFENSIVE );
	   else
	   formations->setFormation( FT_OPEN_DEFENSIVE );           
	   }
	   else{        
	   if (WM->isBallInOurPossesion ())
	   formations->setFormation( FT_334_OFFENSIVE  );
	   else
	   formations->setFormation(FT_DEFENSIVE );                                     
	   }
	   */
}

/*! 盯住对方的截球队员。
 *      此方法只被中场和后卫调用。
 *
 *      if (posMark 附近有对手)
 *         mark对手
 *      else
 *         goToPos (posMark);
 *      
 */
SoccerCommand Player::markOpponent(VecPosition posMark)
{
	SoccerCommand soc(CMD_ILLEGAL);

	//soc = goToPos(posMark);
	//return soc;

	double distToClosestOpp = 100;
	ObjectT oppMark = WM->getClosestInSetTo(OBJECT_SET_OPPONENTS, posMark,&distToClosestOpp);

	if ((oppMark != OBJECT_ILLEGAL)	&& (distToClosestOpp < PS->getMarkDistance())) {
		VecPosition posBall = WM->getBallPos();
		double ballX = posBall.getX();
		double ballY = posBall.getY();
		MarkT mt = MARK_ILLEGAL;
		if ((formations->getPlayerType() == PT_DEFENDER_SWEEPER)
				|| (formations->getPlayerType() == PT_DEFENDER_WING)) {
			if (fabs(posBall.getY()) > 15)
				mt = MARK_BALL;
			else
				mt = MARK_GOAL;
		} else {
			if (posBall.getDistanceTo(posMark) <= 25)
				mt = MARK_BALL;
			else
				mt = MARK_BISECTOR;
		}

		double distMark = PS->getMarkDistance();
		//if (posMark.getX() < -36)
		//	distMark = distMark / 2;

		soc = mark(oppMark, distMark, mt);
		soc = adjustDashPowerForStamina(soc, ACT_MARK);

	} else
		soc = goToPos(posMark);


	return soc;
}


/*! 防止被对方的队员mark。
 *        空点的选择还应该细化，守门员发球时，后卫应该在平行于禁区的一条线移动，但是中场则可以各个方向移动。
 *
 *      if (posStart 附近有对手)
 *         走到一个空的地方
 *      else
 *         goToPos (posStart);
 *      
 */
SoccerCommand Player::remarkOpponent(VecPosition posStrat)
{
	SoccerCommand soc(CMD_ILLEGAL);

	soc = goToPos(posStrat);
	return soc;


	double distToClosestOpp = 100;
	double minDistToClosestOpp = 100;
	ObjectT oppMark = WM->getClosestInSetTo(OBJECT_SET_OPPONENTS, posStrat,
			&distToClosestOpp);

	if ((oppMark != OBJECT_ILLEGAL)
			&& (distToClosestOpp < 1.5 * PS->getMarkDistance())) {
		double minDistToClosetOpp = distToClosestOpp;
		VecPosition posBest = posStrat;
		VecPosition posTry = posStrat;
		for (int i = -7; i <= 7; i++) {
			posTry.setVecPosition(posStrat.getX() + (double)i,
					posStrat.getY());
			ObjectT oppTry =
				WM->getClosestInSetTo(OBJECT_SET_OPPONENTS, posTry,
						&distToClosestOpp);
			if ((oppTry != OBJECT_ILLEGAL)
					&& (distToClosestOpp < minDistToClosetOpp)) {
				posBest = posTry;
				minDistToClosestOpp = distToClosestOpp;
			}
		}
		soc = goToPos(posBest);

	} else
		soc = goToPos(posStrat);

	return soc;
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
/*! 视觉决策部分。
 *         对于球员来说，有两个最重要的观察对象，一个是球，另一个是对方的球门。
 *         
 *         下面给出play_on模式下的视觉部分：
 *               首先确定球和自己身体的角度angBodyToBall，再确定球门和自己身体的角度angBodyToGoal。
 *
 */
SoccerCommand Player::visualDecision(SoccerCommand soc)
{

	SoccerCommand socNeck(CMD_ILLEGAL);
	//ViewAngleT vat             = VA_NORMAL;  //本周期的视觉模式。

	if (WM->getConfidence(OBJECT_BALL) < PS->getBallConfThr()) {
		soc = alignNeckWithBody();
		return soc;
	}


	VecPosition posBall = WM->getBallPos();
	VecPosition posAgent = WM->getAgentGlobalPosition();
	double myX = posAgent.getX();
	double myY = posAgent.getY();
	double distToBall = posAgent.getDistanceTo(posBall);

	//AngDeg angNeck    = WM->getAgentGlobalNeckAngle();
	AngDeg angBody = WM->getAgentGlobalBodyAngle();
	AngDeg angEyeLeft = VecPosition::normalizeAngle(angBody - 80);
	AngDeg angEyeRight = VecPosition::normalizeAngle(angBody + 80);
	AngDeg angArea =
		fabs(VecPosition::normalizeAngle(angEyeLeft - angEyeRight));

	VecPosition posGoal(52.5, 0);
	AngDeg angGoal = (posGoal - posAgent).getDirection();
	AngDeg angBall = (posBall - posAgent).getDirection();
	AngDeg angBallToGoal = VecPosition::normalizeAngle(angGoal - angBall);

	//ViewAngleT    vat       = VA_NORMAL;  //本周期的视觉模式。    
	static int numNormal = 0;	//使用普通视角的次数。
	static int numNarrow = 0;	//连续使用窄视角的次数。

	if (distToBall > 35) {
		if (WM->getViewAngle() != VA_WIDE)
			ACT->putCommandInQueue(setViewAngle(VA_WIDE));
		socNeck = turnNeckToPoint(posBall, soc);
	} else if ((fabs(angBallToGoal) > 80) || (distToBall > 15)) {
		//普通视角，看一下球门，看两次球。
		if (WM->getViewAngle() != VA_NORMAL) {
			numNormal = 0;
			ACT->putCommandInQueue(setViewAngle(VA_NORMAL));
		}

		if (numNormal < 2) {
			socNeck = turnNeckToDirection(angBall, soc);
			numNormal++;
		} else {
			socNeck = turnNeckToDirection(angGoal, soc);
			numNormal = 0;
		}

	} else {
		//两次窄视角，一次普通视角；其中用窄视角看一下球，用窄视角看一下球门，在用宽视角看一下自己可以观察到的不
		//包含球和球门的最大范围。
		AngDeg angBallToLeft =
			fabs(VecPosition::normalizeAngle(angBall - angEyeLeft));
		AngDeg angBallToRight =
			fabs(VecPosition::normalizeAngle(angBall - angEyeRight));
		AngDeg angGoalToLeft =
			fabs(VecPosition::normalizeAngle(angGoal - angEyeLeft));
		AngDeg angGoalToRight =
			fabs(VecPosition::normalizeAngle(angGoal - angEyeRight));
		AngDeg ang3 = angBody;	//指向普通视角的方向。

		if (!isAngInInterval(angBall, angEyeLeft, angEyeRight)) {
			if (!isAngInInterval(angGoal, angEyeLeft, angEyeRight)) {
				ang3 = angBody;
			} else {
				if (angGoalToLeft > angGoalToRight)
					ang3 = getBisectorTwoAngles(angGoal, angEyeLeft);
				else
					ang3 = getBisectorTwoAngles(angGoal, angEyeRight);
			}
		} else {
			if (!isAngInInterval(angGoal, angEyeLeft, angEyeRight)) {
				if (angBallToLeft > angBallToRight)
					ang3 = getBisectorTwoAngles(angBall, angEyeLeft);
				else
					ang3 = getBisectorTwoAngles(angBall, angEyeRight);
			} else {		//两者都在观察范围。
				if ((min(angGoalToLeft, angBallToLeft) >
							min(angGoalToRight, angBallToRight))) {
					if (angGoalToLeft > angBallToLeft)
						ang3 = getBisectorTwoAngles(angEyeLeft, angBall);
					else
						ang3 = getBisectorTwoAngles(angEyeLeft, angGoal);
				} else {
					if (angGoalToRight > angBallToRight)
						ang3 = getBisectorTwoAngles(angEyeRight, angBall);
					else
						ang3 = getBisectorTwoAngles(angEyeRight, angGoal);
				}
			}
		}


		if (WM->getViewAngle() != VA_NARROW) {
			numNarrow = 0;
			ACT->putCommandInQueue(setViewAngle(VA_NARROW));
		}
		if ((WM->getViewAngle() == VA_NARROW) && (numNarrow == 2))
			ACT->putCommandInQueue(setViewAngle(VA_NORMAL));

		if (numNarrow == 0) {
			socNeck = turnNeckToDirection(angBall, soc);
			numNarrow = 1;
		} else if (numNarrow == 1) {
			socNeck = turnNeckToDirection(angGoal, soc);
			numNarrow = 2;
		} else {
			socNeck = turnNeckToDirection(ang3, soc);
			numNarrow = 0;
		}
	}

	return socNeck;

}

/*!守门员的决策部分。
 *  当然仍然使用UvA自带的守门员策略。
 *  缺点是不是沿线防守。
 */
void Player::goalieStrategy()
{
	int i;
	SoccerCommand soc;
	VecPosition posAgent = WM->getAgentGlobalPosition();
	AngDeg angBody = WM->getAgentGlobalBodyAngle();

	// define the top and bottom position of a rectangle in which keeper moves
	static const VecPosition posLeftTop(-PITCH_LENGTH / 2.0 +
			0.7 * PENALTY_AREA_LENGTH,
			-PENALTY_AREA_WIDTH / 4.0);
	static const VecPosition posRightTop(-PITCH_LENGTH / 2.0 +
			0.7 * PENALTY_AREA_LENGTH,
			+PENALTY_AREA_WIDTH / 4.0);

	if (WM->isBeforeKickOff()) {
		if (formations->getFormation() != FT_INITIAL ||	// not in kick_off formation
				posAgent.getDistanceTo(WM->getStrategicPosition()) > 2.0) {
			formations->setFormation(FT_INITIAL);	// go to kick_off formation
			ACT->
				putCommandInQueue(teleportToPos
						(WM->getStrategicPosition()));
		} else			// else turn to center
		{
			ACT->putCommandInQueue(turnBodyToPoint(VecPosition(0, 0), 0));
			ACT->putCommandInQueue(alignNeckWithBody());
		}
		return;
	}

	if (WM->getConfidence(OBJECT_BALL) < PS->getBallConfThr()) {	// confidence ball too  low
		ACT->putCommandInQueue(searchBall());	// search ball
		ACT->putCommandInQueue(alignNeckWithBody());
	} else if (WM->getPlayMode() == PM_PLAY_ON || WM->isFreeKickThem() || WM->isCornerKickThem() || WM->isBackPassUs()) {	//add by orit
		if (WM->isBallCatchable()) {
			ACT->putCommandInQueue(soc = catchBall());
			ACT->putCommandInQueue(turnNeckToObject(OBJECT_BALL, soc));
		} else if (WM->isBallKickable()) {
			soc = kickTo(VecPosition(0, posAgent.getY() * 2.0), 2.0);
			ACT->putCommandInQueue(soc);
			ACT->putCommandInQueue(turnNeckToObject(OBJECT_BALL, soc));
		} else if (WM->
				isInOwnPenaltyArea(getInterceptionPointBall(&i, true))
				&& WM->getFastestInSetTo(OBJECT_SET_PLAYERS,
					OBJECT_BALL,
					&i) ==
				WM->getAgentObjectType()) {
			ACT->putCommandInQueue(soc = intercept(true));
			ACT->putCommandInQueue(turnNeckToObject(OBJECT_BALL, soc));
		} else {
			//由矩形防守改为直线防守。
			soc = defendGoalLine(3);
			ACT->putCommandInQueue(soc);
			ACT->putCommandInQueue(turnNeckToObject(OBJECT_BALL, soc));
		}
	} else if (WM->isFreeKickUs() == true || WM->isGoalKickUs() == true) {
		if (WM->isBallKickable()) {
			if (WM->getTimeSinceLastCatch() == 25 && WM->isFreeKickUs()) {
				// move to position with lesser opponents.
				if (WM->
						getNrInSetInCircle(OBJECT_SET_OPPONENTS,
							Circle(posRightTop,
								15.0)) <
						WM->getNrInSetInCircle(OBJECT_SET_OPPONENTS,
							Circle(posLeftTop, 15.0)))
					soc.makeCommand(CMD_MOVE, posRightTop.getX(),
							posRightTop.getY(), 0.0);  //orit
				else
					soc.makeCommand(CMD_MOVE, posLeftTop.getX(),
							posLeftTop.getY(), 0.0);
				ACT->putCommandInQueue(soc);
			} else if (WM->getTimeSinceLastCatch() > 28) {
				ObjectT tmtPass = OBJECT_ILLEGAL;
				AngDeg angPass = 0;
				double speedPass = 2.0;
				if (WM->canSmartPassBallToTmt(tmtPass, angPass, speedPass))
					soc = smartPassBallToTmt(tmtPass, angPass, speedPass);
				else
					soc =
						kickTo(VecPosition(0, posAgent.getY() * 2.0), 2.0);
				ACT->putCommandInQueue(soc);
			} else if (WM->getTimeSinceLastCatch() < 25) {
				VecPosition posSide(0.0, posAgent.getY());
				if (fabs((posSide - posAgent).getDirection() - angBody) >
						10) {
					soc = turnBodyToPoint(posSide);
					ACT->putCommandInQueue(soc);
				}
				ACT->putCommandInQueue(turnNeckToObject(OBJECT_BALL, soc));
			}
		} else if (WM->isGoalKickUs()) {
			ACT->putCommandInQueue(soc = intercept(true));
			ACT->putCommandInQueue(turnNeckToObject(OBJECT_BALL, soc));
		} else
			ACT->putCommandInQueue(turnNeckToObject(OBJECT_BALL, soc));
	} else {
		ACT->putCommandInQueue(soc = turnBodyToObject(OBJECT_BALL));
		ACT->putCommandInQueue(turnNeckToObject(OBJECT_BALL, soc));
	}

}

/*! 后卫的决策。
 *
 */
SoccerCommand Player::defenderStrategy()
{

	SoccerCommand soc(CMD_ILLEGAL);

	// for goal
	VecPosition posGoal(52.5, 0);

	//for me
	VecPosition posAgent = WM->getAgentGlobalPosition();
	VecPosition posStrat = WM->getMyStrategicPosition();
	double myX = posAgent.getX();
	double myY = posAgent.getY();
	int area = WM->getPosArea(posAgent);	//自己所在的区域。
	SideT sideType = WM->getSide();
	AngDeg angBody = WM->getAgentGlobalBodyAngle();
	AngDeg angBody2Goal =
		VecPosition::normalizeAngle((posGoal - posAgent).getDirection() -
				angBody);
	int numOpp4 = WM->getNrInSetInCircle(OBJECT_SET_OPPONENTS,
			Circle(posAgent, 4.0));

	// for ball
	VecPosition posBall = WM->getBallPos();
	double spBall = WM->getBallSpeed();

	// for shoot
	VecPosition posShoot(PITCH_LENGTH / 2.0,
			(-1 +
			 2 * (WM->getCurrentCycle() % 2)) * 0.4 *
			SS->getGoalWidth());

	// for pass
	ObjectT tmtPass = OBJECT_ILLEGAL;
	VecPosition posPass;
	AngDeg angPass = 0;
	double speedPass = 2.0;

	// for through pass
	ObjectT tmtThroughPass = OBJECT_ILLEGAL;
	VecPosition posThroughPass(52.5, 0);
	AngDeg angThroughPass = 0;
	double speedThroughPass = 2.0;

	//for dribble
	AngDeg angDribble = 0;

	// for intercept
	int iTmp;

	formationDecision();	//确定比赛阵型。
	if (WM->getConfidence(OBJECT_BALL) < PS->getBallConfThr()) {
		soc = searchBall();	// if ball pos unknown
	} else if (WM->isBallKickable()) {	// if kickable

		//------------------------------------------------------//
		double shootP = WM->getAgentShootProbability(posShoot);

		if (shootP > 0.9) {
			soc = shoot(posShoot);
			Log.logWithTime(777, " shoot with the p (%f)", shootP);
			//cout << endl << "shoot   !  " << shootP * 100;
			return soc;
		} else if (WM->canSmartPassBallToTmt(tmtPass, angPass, speedPass)) {
			soc = smartPassBallToTmt(tmtPass, angPass, speedPass);
			Log.logWithTime(777, " pass to tmt(%d)",
					SoccerTypes::getIndex(tmtPass) + 1);
		} else if (fabs(angBody2Goal) > 90 && numOpp4 == 0) {
			if (spBall < 1.7) {
				soc =
					turnWithBallTo(0, PS->getTurnWithBallAngThr(),
							PS->getTurnWithBallFreezeThr());
				Log.logWithTime(777, " turn with ball");
			} else {
				soc = freezeBall();
				Log.logWithTime(777, " freeze ball");
			}
		} else if (WM->canDribble(angDribble, DRIBBLE_FAST)) {
			soc = dribble(angDribble, DRIBBLE_FAST);
			Log.logWithTime(777, " dribble fast ");
		} else if (WM->canDribble(angDribble, DRIBBLE_SLOW)) {
			soc = dribble(angDribble, DRIBBLE_SLOW);
			Log.logWithTime(777, " dribble slow ");
		} else if (area == 1) {
			soc = clearBall(CLEAR_BALL_DEFENSIVE, sideType);
			Log.logWithTime(777, " clear defensive ");
		} else if (area == 2) {
			soc = clearBall(CLEAR_BALL_OFFENSIVE_SIDE, sideType);
			Log.logWithTime(777, " clear offensive ");
		} else if (area == 3) {
			soc = clearBall(CLEAR_BALL_OFFENSIVE, sideType);
			Log.logWithTime(777, " clear offensive side ");