command.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: Mohsen Izadi
 *  Modified by: Ahmad Boorghany, Mohammad Salehe
 *  Released on Friday 1 April 2005 by Mersad RoboCup Team.
 *  For more information please read README file.
*/

#include <Command.h>
#include <sstream>

using namespace std;


// class Command

Command::Command()
{
}

Command::~Command()
{
}


// class AttentionToCommand

AttentionToCommand::AttentionToCommand(TeamId teamId, int uniformNum): 
	teamId(teamId), uniformNum(uniformNum)
{
}

AttentionToCommand::~AttentionToCommand()
{
}

string AttentionToCommand::toString() const
{
	ostringstream ss;
	ss << "(attentionto " << (teamId == TID_TEAMMATE ? "our " : "opp ")
		<< uniformNum << ")";
	return ss.str();
}

TeamId AttentionToCommand::getTeamId() const
{
	return teamId;
}

int AttentionToCommand::getUniformNum() const
{
	return uniformNum;
}


// class ByeCommand

ByeCommand::ByeCommand()
{
}

ByeCommand::~ByeCommand()
{
}

string ByeCommand::toString() const
{
	return "(bye)";
}


// class CatchCommand

CatchCommand::CatchCommand(float direction): direction(direction)
{
}

CatchCommand::~CatchCommand()
{
}

string CatchCommand::toString() const
{
	ostringstream ss;
	ss.setf(ios::fixed | ios::showpoint);
	ss.precision(2);
	ss << "(catch " << -direction << ")";
	return ss.str();
}

float CatchCommand::getDirection() const
{
	return direction;
}


// class ChangeViewCommand

ChangeViewCommand::ChangeViewCommand(ViewModeQuality quality, 
	ViewModeWidth width): quality(quality), width(width)
{
}

ChangeViewCommand::~ChangeViewCommand()
{
}

string ChangeViewCommand::toString() const
{
	string res = "(change_view ";
	switch (width)
	{
	case VMW_NARROW:
		res += "narrow ";
		break;
	case VMW_NORMAL:
		res += "normal ";
		break;
	case VMW_WIDE:
		res += "wide ";
		break;
	}
	res += (quality == VMQ_LOW ? "low" : "high");
	res += ")";
	return res;
}

ViewModeQuality ChangeViewCommand::getQuality() const
{
	return quality;
}

ViewModeWidth ChangeViewCommand::getWidth() const
{
	return width;
}


// class DashCommand

DashCommand::DashCommand(float power): power(power)
{
}

DashCommand::~DashCommand()
{
}

string DashCommand::toString() const
{
	ostringstream ss;
	ss.setf(ios::fixed | ios::showpoint);
	ss.precision(2);
	ss << "(dash " << power << ")";
	return ss.str();
}

float DashCommand::getPower() const
{
	return power;
}

void DashCommand::setPower(float powerArg)
{
	power = powerArg;
}

// class DoneCommand

DoneCommand::DoneCommand()
{
}

DoneCommand::~DoneCommand()
{
}

string DoneCommand::toString() const
{
	return "(done)";
}


// class EmptyCommand

EmptyCommand::EmptyCommand()
{
}

EmptyCommand::~EmptyCommand()
{
}

string EmptyCommand::toString() const
{
	return "";
}


// class InitCommand

InitCommand::InitCommand(const std::string &teamName, const std::string &version, 
	bool isGoalie): teamName(teamName), version(version), isGoalie(isGoalie)
{
}

InitCommand::~InitCommand()
{
}

string InitCommand::toString() const
{
	ostringstream ss;
	ss << "(init " << teamName << " (version " << version << ")" 
		<< (isGoalie ? "(goalie))" : ")");
	return ss.str();
}

const string &InitCommand::getTeamName() const
{
	return teamName;
}

const string &InitCommand::getVersion() const
{
	return version;
}

bool InitCommand::getIsGoalie() const
{
	return isGoalie;
}


// class KickCommand

KickCommand::KickCommand(float power, float direction): power(power),
	direction(direction)
{
}

KickCommand::~KickCommand()
{
}

string KickCommand::toString() const
{
	ostringstream ss;
	ss.setf(ios::fixed | ios::showpoint);
	ss.precision(2);
	ss << "(kick " << power << " " << -direction << ")";
	return ss.str();
}

float KickCommand::getPower() const
{
	return power;
}

float KickCommand::getDirection() const
{
	return direction;
}

void KickCommand::setPower(float powerArg)
{
	power = powerArg;
}

void KickCommand::setDirection(float directionArg)
{
	direction = directionArg;
}


// class MoveCommand

MoveCommand::MoveCommand(Point point): x(point.x), y(point.y)
{
}

MoveCommand::MoveCommand(float x, float y): x(x), y(y)
{
}

MoveCommand::~MoveCommand()
{
}

string MoveCommand::toString() const
{
	ostringstream ss;
	ss.setf(ios::fixed | ios::showpoint);
	ss.precision(2);
	ss << "(move " << x << " " << -y << ")";
	return ss.str();
}

float MoveCommand::getX() const
{
	return x;
}

float MoveCommand::getY() const
{
	return y;
}


// class PointToCommand

PointToCommand::PointToCommand(bool status):
		status(status), dist(0), dir(0)
{
}

PointToCommand::PointToCommand(float dist, float dir):
		status(true), dist(dist), dir(dir)
{
}

PointToCommand::~PointToCommand()
{
}

string PointToCommand::toString() const
{
	ostringstream ss;

	if (status)
	{
		ss.setf(ios::fixed | ios::showpoint);
		ss.precision(2);
		ss << "(pointto " << dist << " " << -dir << ")";
	}
	else
		ss << "(pointto off)";

	return ss.str();
}

float PointToCommand::getDist() const
{
	return dist;
}

float PointToCommand::getDir() const
{
	return dir;
}


// class SayCommand

SayCommand::SayCommand(const string &message): message(message)
{
}

SayCommand::~SayCommand()
{
}

string SayCommand::toString() const
{
	return "(say \"" + message + "\")";
}

const string &SayCommand::getMessage() const
{
	return message;
}


// class TackleCommand

TackleCommand::TackleCommand(float power): power(power)
{
}

TackleCommand::~TackleCommand()
{
}

string TackleCommand::toString() const
{
	ostringstream ss;
	ss.setf(ios::fixed | ios::showpoint);
	ss.precision(2);
	ss << "(tackle " << power << ")";
	return ss.str();
}

float TackleCommand::getPower() const
{
	return power;
}


// class TurnCommand

TurnCommand::TurnCommand(float direction): direction(direction)
{
}

TurnCommand::~TurnCommand()
{
}

string TurnCommand::toString() const
{
	ostringstream ss;
	ss.setf(ios::fixed | ios::showpoint);
	ss.precision(2);
	ss << "(turn " << -direction << ")";
	return ss.str();
}

float TurnCommand::getDirection() const
{
	return direction;
}

float TurnNeckCommand::getDirection() const
{
	return direction;
}


// class TurnNeckCommand

TurnNeckCommand::TurnNeckCommand(float direction): direction(direction)
{
}

TurnNeckCommand::~TurnNeckCommand()
{
}

string TurnNeckCommand::toString() const
{
	ostringstream ss;
	ss.setf(ios::fixed | ios::showpoint);
	ss.precision(2);
	ss << "(turn_neck " << -direction << ")";
	return ss.str();
}


// class EyeCommand

EyeCommand::EyeCommand(bool on): on(on)
{
}

EyeCommand::~EyeCommand()
{
}

string EyeCommand::toString() const
{
	if (on)
		return "(eye on)";
	return "(eye off)";
}

bool EyeCommand::isOn() const
{
	return on;
}


// class EyeCommand

ChangePlayerCommand::ChangePlayerCommand(int uniformNum, int playerType):
	uniformNum(uniformNum), playerType(playerType)
{
}

ChangePlayerCommand::~ChangePlayerCommand()
{
}

string ChangePlayerCommand::toString() const
{
	ostringstream ss;
	ss.setf(ios::fixed | ios::showpoint);
	ss.precision(2);
	ss << "(change_player_type " << uniformNum << " " << playerType << ")";
	return ss.str();
}

int ChangePlayerCommand::getUniformNum() const
{
	return uniformNum;
}

int ChangePlayerCommand::getPlayerType() const
{
	return playerType;
}


// class FreeFormCommand

FreeFormCommand::FreeFormCommand(const string &message): message(message)
{
}

FreeFormCommand::~FreeFormCommand()
{
}

string FreeFormCommand::toString() const
{
	return "(say (freeform \"" + message + "\"))";
}

const string &FreeFormCommand::getMessage() const
{
	return message;
}


// class CLangVersionCommand

CLangVersionCommand::CLangVersionCommand(int minVer, int maxVer): minVer(minVer), maxVer(maxVer)
{
}

CLangVersionCommand::~CLangVersionCommand()
{
}

string CLangVersionCommand::toString() const
{
	ostringstream ss;
	ss.setf(ios::fixed);
	ss.precision(0);
	ss << "(clang (ver " << minVer << " " << maxVer << "))";
	return ss.str();
}

int CLangVersionCommand::getMinVer() const
{
	return minVer;
}

int CLangVersionCommand::getMaxVer() const
{
	return maxVer;
}