statelessplan.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: Arash Rahimi, 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 <Logger.h>
#include <Defines.h>
#include <SyncedAgent.h>
#include <Positioning.h>
#include <iostream>
#include <StatelessPlan.h>

#include <AdvancedAgent.h>


using namespace std;

StatelessPlan::~StatelessPlan() 
{ 
}  


StatelessPlan::StatelessPlan(const WorldModel *wm, Form &form,
		const Library &library):
		Plan("Stateless", wm, form, library), nonPlayOnDecision(wm),
		penaltyDecision(wm), goaliePlayOnDecision(wm), withBallPlayOnDecision(wm),
		withoutBallPlayOnDecision(wm)
{
 	LOG << "StatelessPlan::@CONSTRUCTOR --> Constructor called!" << endl;	
	sayCycleCommand = bodyCycleCommand = headCycleCommand =
		pointToCycleCommand = attentionCycleCommand =
		changeViewCycleCommand = NULL;
}

void StatelessPlan::senseBody(const SExpression &exp)
{
	sayCycleCommand = bodyCycleCommand = headCycleCommand =
		pointToCycleCommand = attentionCycleCommand =
		changeViewCycleCommand = NULL;
	
	nonPlayOnDecision.updateAfterSenseBody();
	withBallPlayOnDecision.updateAfterSenseBody();
	withoutBallPlayOnDecision.updateAfterSenseBody();

}

void StatelessPlan::see(const SExpression &exp)
{
}

void StatelessPlan::hear(const SExpression &exp)
{
}

void StatelessPlan::decide()
{
	LOG << "StatelessPlan::decide" << endl;

	bool kickPermission = true;
	if (wm->getBallStatus() == BS_KICKABLE_BODY_TMM &&
		(library.lastBodyCycleCommand->getCreator() == AT_NONE ||
		 library.lastBodyCycleCommand->getCreator() == AT_OFFENSE ||
		 library.lastBodyCycleCommand->getCreator() == AT_DEFENSE ||
		 library.lastBodyCycleCommand->getCreator() == AT_INTERCEPT ||
		 library.lastBodyCycleCommand->getCreator() == AT_DRIBBLE_INTERCEPT ||
		 library.lastBodyCycleCommand->getCreator() == AT_LOOK_FOR_BALL ||
		 library.lastBodyCycleCommand->getCreator() == AT_BLOCK))
		kickPermission = false;

	if (wm->getPlayMode() == PM_PLAY_ON ||
		(wm->getPlayMode() == PM_GOAL_KICK &&
		 wm->getVirtualPlayMode() == VPM_GOAL_KICK_TAKEN))
	{
		if (!wm->getBall().isValid())
		{
			LOG << "Looking for ball." << endl;
			form.headForm.tnMode = TNM_LOOK_NORMALLY;

			bodyCycleCommand = new TurnCommand(AT_LOOK_FOR_BALL, 45);
		}
		else if (wm->getBody().isGoalie())
		{
			goaliePlayOnDecision.decide(library.quickLevel, form, library);
			bodyCycleCommand = goaliePlayOnDecision.getCommand();
		}
		else if (wm->isBallKickable() && kickPermission)
		{
//			if (library.quickLevel <= 0)
//				wm->updateCurKickCalculate();

			withBallPlayOnDecision.decide(library.quickLevel, form, library);
			bodyCycleCommand = withBallPlayOnDecision.getCommand();

			setLastWithBallDecideValid(true);
		}
		else
		{
			checkForLastWithBallDecideValid();

			WithoutBallSelection wobSelection;
			if (isLastWithBallDecideValid() &&
				withBallPlayOnDecision.getLastWithBallDecide() == AT_SRPDRIBBLE)
			{
				LOG << "I will Intercept to ball immediately." << endl;
				wobSelection = WOBS_INTERCEPT;
			}
			else
				wobSelection = library.gwSelection;

			withoutBallPlayOnDecision.decide(library.quickLevel,
					wobSelection, form, library);
			bodyCycleCommand = withoutBallPlayOnDecision.getCommand();
		}
	}
	else if (wm->getPlayMode() == PM_PENALTY_SETUP ||
			wm->getPlayMode() == PM_PENALTY_SETUP_OPP ||
			wm->getPlayMode() == PM_PENALTY_READY ||
			wm->getPlayMode() == PM_PENALTY_READY_OPP)

	{
		if (!wm->getBall().isValid())
		{
			LOG << "Looking for ball." << endl;
			form.headForm.tnMode = TNM_LOOK_NORMALLY;

			bodyCycleCommand = new TurnCommand(AT_LOOK_FOR_BALL, 45);
		}
		else
		{	
/*			if (library.quickLevel <= 0 && wm->isBallKickable())
			{
				LOG << "PENALTY: updateCurKickCalculate() ..." << endl;
				wm->updateCurKickCalculate();
				LOG << "PENALTY: updated." << endl;
			}*/

			penaltyDecision.decide(library.quickLevel, form, library);
			bodyCycleCommand = penaltyDecision.getCommand();
		}
	}
	else
	{
		if (!wm->getBall().isValid())
		{
			LOG << "Looking for ball." << endl;
			form.headForm.tnMode = TNM_LOOK_NORMALLY;

			bodyCycleCommand = new TurnCommand(AT_LOOK_FOR_BALL, 45);
		}
		else
		{
//			if (library.quickLevel <= 0 && wm->isBallKickable())
//				wm->updateCurKickCalculate();

			nonPlayOnDecision.decide(library.quickLevel, form, library);
			bodyCycleCommand = nonPlayOnDecision.getCommand();
		}
	}

	if (!bodyCycleCommand)
		bodyCycleCommand = new EmptyCommand(AT_NONE);

	throw bodyCycleCommand;
}

double StatelessPlan::successRate()
{
	return 1.0;
}

bool StatelessPlan::isFinished()
{
	return false;
}

void StatelessPlan::checkForLastWithBallDecideValid()
{
	if (wm->getBallStatus() == BS_KICKABLE_TMM ||
		wm->getBallStatus() == BS_KICKABLE_OPP ||
		wm->getBallStatus() == BS_KICKABLE_TMM_OPP)
		setLastWithBallDecideValid(false);

}

// Getting functions
bool StatelessPlan::isLastWithBallDecideValid() const
{
	return lastWithBallDecideValidFlag;
}

// Setting functions
void StatelessPlan::setLastWithBallDecideValid(bool lastWithBallDecideValidArg)
{
	lastWithBallDecideValidFlag = lastWithBallDecideValidArg;
}