nonplayon.cpp

mersad源码 03年robocup 季军 可以研究一下大家

/*
 *  Copyright 2002-2004, Mersad Team, Allame 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.
 *
 *  Created by: Mohammad Salehe
 *  Released on Friday 1 April 2005 by Mersad RoboCup Team.
 *  For more information please read README file.
*/

#include <iostream>
#include <cassert>

#include <Logger.h>
#include <NonPlayOn.h>
#include <BasicTurn.h>
#include <BasicDash.h>
#include <BasicKick.h>

using namespace std;

// NonPlayOnBackBall
NonPlayOnBackBall::NonPlayOnBackBall(const WorldModel *worldModel): 
		AdvancedAction(worldModel)
{
}

float NonPlayOnBackBall::getValue()
{
	command = NULL;
	return 100;
}

void NonPlayOnBackBall::execute(SayDecisionFlags &sayFlags)
{
	Point movePoint;
	movePoint.x = -40;
	movePoint.y = -10;

	if (worldModel->getPlayMode() == PM_FREE_KICK &&
		worldModel->getVirtualPlayMode() == VPM_GOALIE_CATCH_BALL &&
		(worldModel->getBody().getPos() - movePoint).getMagnitude() > 3.1 &&
		worldModel->getPlayModeRemainCycle() > 198) 
	{
		command = new MoveCommand(movePoint);
		status = 0; 
	}
	else
	{	
		command = TurnToPoint(Point(52.5, 0),
			   			worldModel->getBody()).getCommand();
		status = 0;
	}
}

int NonPlayOnBackBall::getStatus()
{
	return status;
}

DecideType NonPlayOnBackBall::getType()
{
	return DT_NON_PLAY_ON_BACK_BALL;
}

// NonPlayOnGotoKick
NonPlayOnGotoKick::NonPlayOnGotoKick(const WorldModel *worldModel): 
		AdvancedAction(worldModel)
{
}

float NonPlayOnGotoKick::getValue()
{
	Vector playerGoal;
	command = NULL;
	playerGoal.setByPoints(worldModel->getBody().getPos(), Point(50, 0));
	if (worldModel->getPlayMode() == PM_KICK_OFF || 
		worldModel->getPlayMode() == PM_FREE_KICK ||
		worldModel->getPlayMode() == PM_KICK_IN ||
		worldModel->getPlayMode() == PM_OFFSIDE_OPP ||
		worldModel->getPlayMode() == PM_GOAL_KICK ||
		worldModel->getPlayMode() == PM_CORNER_KICK ||
		worldModel->getPlayMode() == PM_FREE_KICK_FAULT_OPP ||
		worldModel->getPlayMode() == PM_CATCH_FAULT_OPP ||
		worldModel->getPlayMode() == PM_BACK_PASS_OPP ||

		worldModel->getPlayMode() == PM_PENALTY_READY ||
		worldModel->getPlayMode() == PM_PENALTY_READY_OPP ||
		worldModel->getPlayMode() == PM_PENALTY_SETUP ||
		worldModel->getPlayMode() == PM_PENALTY_SETUP_OPP)

		{
			LOG << "GOTOKICK OK" << endl;
			FreeKickGotoPoint doGotoPoint(worldModel->getBall().getPos(),
				playerGoal.getDirection(), worldModel->getBall().getSize(),
				worldModel->getBody());
			if (doGotoPoint.getCommand()) delete doGotoPoint.getCommand();
			status = doGotoPoint.getStatus();
		}
		else
		{
			LOG << "GOTOKICK WHAT?(CHECK IT)" << endl;
			ForbiddenAreaGotoPoint doGotoPoint(worldModel->getBall().getPos(),
				playerGoal.getDirection(), worldModel->getBall().getSize(),
				worldModel->getBody());
			if (doGotoPoint.getCommand()) delete doGotoPoint.getCommand();
			status = doGotoPoint.getStatus();
		}
	return 100;
}

int NonPlayOnGotoKick::getStatus()
{
	return status;
}

void NonPlayOnGotoKick::execute(SayDecisionFlags &sayFlags)
{
	Vector playerGoal;
	command = NULL;
	playerGoal.setByPoints(worldModel->getBody().getPos(), Point(50, 0));
	if (worldModel->getPlayMode() == PM_KICK_OFF || 
		worldModel->getPlayMode() == PM_FREE_KICK ||
		worldModel->getPlayMode() == PM_KICK_IN ||
		worldModel->getPlayMode() == PM_OFFSIDE_OPP ||
		worldModel->getPlayMode() == PM_GOAL_KICK ||
		worldModel->getPlayMode() == PM_CORNER_KICK ||
		worldModel->getPlayMode() == PM_FREE_KICK_FAULT_OPP ||
		worldModel->getPlayMode() == PM_CATCH_FAULT_OPP ||
		worldModel->getPlayMode() == PM_BACK_PASS_OPP ||

		worldModel->getPlayMode() == PM_PENALTY_READY ||
		worldModel->getPlayMode() == PM_PENALTY_READY_OPP ||
		worldModel->getPlayMode() == PM_PENALTY_SETUP ||
		worldModel->getPlayMode() == PM_PENALTY_SETUP_OPP)
		{
			FreeKickGotoPoint doGotoPoint(worldModel->getBall().getPos(),
				playerGoal.getDirection(), worldModel->getBall().getSize(),
				worldModel->getBody());
			command = doGotoPoint.getCommand();
			if (command == NULL)
				command =new EmptyCommand();
			status = doGotoPoint.getStatus();
		}
		else
		{
			ForbiddenAreaGotoPoint doGotoPoint(worldModel->getBall().getPos(),
				playerGoal.getDirection(), worldModel->getBall().getSize(),
				worldModel->getBody());
			command = doGotoPoint.getCommand();
			if (command == NULL)
				command =new EmptyCommand();
			status = doGotoPoint.getStatus();
		}
}

DecideType NonPlayOnGotoKick::getType()
{
	return DT_NON_PLAY_ON_GOTO_KICK;
}

// NonPlayOnBeforeKickOff
NonPlayOnBeforeKickOff::NonPlayOnBeforeKickOff(const WorldModel *worldModel): 
		AdvancedAction(worldModel)
{
}

float NonPlayOnBeforeKickOff::getValue()
{
	command = NULL;
	return 100;
}

void NonPlayOnBeforeKickOff::execute(SayDecisionFlags &sayFlags)
{
	//TODO : check distance if you are near and don't move and turn
	Point movePoint;
	command = NULL;
	movePoint = getMovePoint();
	LOG << "NONPLAYON(BKO) movePoint : " << movePoint << endl;
	if (worldModel->getPlayMode() == PM_BEFORE_KICK_OFF &&
		(movePoint - Point(0, 0)).getMagnitude() < 9.15) //FIXME :: 9 = serverparam
	{
		Vector moveVector;
		moveVector.setByPoints(Point(0, 0), movePoint);
		moveVector.setAsPolar(9.15 + 0.1, moveVector.getDirection());
		movePoint = Point(0, 0) + moveVector;
	}
	if ((movePoint - worldModel->getBody().getPos()).getMagnitude() < 0.2 || 
			(worldModel->getPlayMode() != PM_BEFORE_KICK_OFF &&
			worldModel->getPlayMode() != PM_GOAL &&
			worldModel->getPlayMode() != PM_GOAL_OPP))
	{
		if (kickerFlag)
			command	= TurnToPoint(Point(-52.5, 0), worldModel->getBody()).getCommand();
		else
			command	= TurnToPoint(Point(0, 0), worldModel->getBody()).getCommand();
	}
	else
	{
		command = new MoveCommand(getMovePoint());
	}
}

Point NonPlayOnBeforeKickOff::getMovePoint(unsigned uniNum)
{
	switch (Player::uniNumToPostNum(uniNum))
	{
	case 1:
		return Point(-47, 0);
	case 2:
		return Point(-13, -16);
	case 3:
		return Point(-16, -5);
	case 4:
		return Point(-16, 5);
	case 5:
		return Point(-14, 16);
	case 6:
		return Point(-5, 13.5);
	case 7:
		return Point(-5, -13.5);
	case 8:
		return Point(-12, 0);
	case 9:
		return Point(-0.5, 0);
	case 10:
		return Point(-.8, -15);
	case 11:
		return Point(-.8, 15);
	}

	assert(0);
	return Point(0, 0);
}

Point NonPlayOnBeforeKickOff::getMovePoint()
{
	return getMovePoint(worldModel->getBody().getUniNum());	
}

DecideType NonPlayOnBeforeKickOff::getType()
{
	return DT_NON_PLAY_ON_BEFORE_KICK_OFF;
}

void NonPlayOnBeforeKickOff::setIsKicker(bool kickerFlagArg)
{
	kickerFlag = kickerFlagArg;
}

// GoalieCatchOffense
GoalieCatchOffense::GoalieCatchOffense(const WorldModel *worldModel): 
		AdvancedAction(worldModel)
{
}

float GoalieCatchOffense::getValue()
{
	command = NULL;
	return 100;
}

void GoalieCatchOffense::execute(SayDecisionFlags &sayFlags)
{
	Point homePoint;
	Point movePoint;
	command = NULL;
	homePoint = getHomePoint();
	LOG << "GoalieCatchOffense(BKO) homePoint : " << homePoint << endl;

	DashNormalGotoPoint doGotoPoint(homePoint, 1.6, worldModel->getBody());

	if (worldModel->getBody().isGoalie())
	{
		movePoint.x = -40;
		movePoint.y = 18;

		if ((worldModel->getBody().getPos() - movePoint).getMagnitude() > 1.8) 
		{
			LOG << "GoalieCatchOffense goalie stat=1" << endl;
			command = new MoveCommand(movePoint);
			status = 1; 
		}
		else
		{	
			LOG << "GoalieCatchOffense goalie stat=0" << endl;
			command = new EmptyCommand();
			status = 0;
		}
		return;
	}

	if (doGotoPoint.getMode() == CT_EMPTY)
	{
		if (doGotoPoint.getCommand())
			delete doGotoPoint.getCommand();
		LOG << "GoalieCatchOffense player stat=turntoball" << endl;
		command = TurnToPoint(worldModel->getBall().getPos(), worldModel->getBody() ,5).
			getCommand();
	}
	else
	{
		command = doGotoPoint.getCommand();
	}
}

Point GoalieCatchOffense::getHomePoint(unsigned uniNum)
{
	if (worldModel->getPlayMode() == PM_GOAL_KICK)
	{
		switch (Player::uniNumToPostNum(uniNum))
		{
		case 1:
			return Point(-47, 0);
		case 2:
			return Point(-30, -20);
		case 3:
			if (worldModel->getBall().getPos().getY() > 0)
				return Point(-33, -2);
			else
				return Point(-39, -11);
		case 4:
			if (worldModel->getBall().getPos().getY() > 0)
				return Point(-39, 11);
			else
				return Point(-33, 2);
		case 5:
			return Point(-30, 20);
		case 6:
			return Point(-18, 15);
		case 7:
			return Point(-10, -15);
		case 8:
			if (worldModel->getBall().getPos().getY() > 0)
				return Point(-33, 11);
			else
				return Point(-33, -11);
		case 9:
			return Point(-1, 0);
		case 10:
			return Point(-1, -20);
		case 11:
			return Point(-1, 20);
		}
	}
	else
	{
		switch (Player::uniNumToPostNum(uniNum))
		{
		case 1:
			return Point(-47, 0);
		case 2:
			return Point(-33, -22);
		case 3:
			return Point(-33, 0);
		case 4:
			return Point(-33, 8);
		case 5:
			return Point(-33, 28);
		case 6:
			return Point(-18, 28);
		case 7:
			return Point(-18, -18);
		case 8:
			return Point(-30, 7);
		case 9:
			return Point(-2, 7);
		case 10:
			return Point(-2, -15);
		case 11:
			return Point(-2, 28);
		}
	}

	assert(0);
	return Point(0, 0);
}

Point GoalieCatchOffense::getHomePoint()
{
	return getHomePoint(worldModel->getBody().getUniNum());	
}

DecideType GoalieCatchOffense::getType()
{
	return DT_GOALIE_CATCH_OFFENSE;
}

int GoalieCatchOffense::getStatus()
{
	return status;
}

// HoldBall
HoldBall::HoldBall(const WorldModel *worldModel): 
		AdvancedAction(worldModel)
{
}

float HoldBall::getValue()
{
	if (worldModel->getPlayModeRemainCycle() > 120)
	{ // wait
		LOG << "HoldBall::getValue (wait/value = 67)" << endl;
		command = NULL;
		return 67;
	}
	else
	{ // ready to pass
		LOG << "HoldBall::getValue (pass/value = 35)" << endl;
		command = NULL;
		return 35;
	}
}

void HoldBall::execute(SayDecisionFlags &sayFlags)
{
	LOG << "HoldBall::execute" << endl;
	command = KickToPointArriveVelocity(worldModel->getBall().getPos(), 0,
			worldModel->getBall(), worldModel->getBody()).getCommand();
}

DecideType HoldBall::getType()
{
	return DT_HOLD_BALL;
}