gamestate.cpp

浙江大学 RoboCup3D 2006 源代码

/***************************************************************************
 *   Copyright (C) 2004 - 2006 by ZJUBase                                  *
 *                                National Lab of Industrial Control Tech. *
 *                                Zhejiang University, China               *

*                                                                         *
 *   Team members:                                                         *
 *    Currently the team leader is,                                        *
 *           Hao JIANG ([e-mail]; [e-mail])       *
 *    In the next season, the leader will be                               *
 *           Yifeng ZHANG ([e-mail])                        *
 *    ZJUBase 3D agent is created by                                       *
 *           Dijun LUO ([e-mail])                             *
 *    All the members who has ever contributed:                            *
 *           Jun JIANG                                                     *
 *           Xinfeng DU ([e-mail])                             *
 *           Yang ZHOU ([e-mail])                             *
 *           Zhipeng YANG                                                  *
 *           Xiang FAN                                                     *
 *                                                                         *
 *   Team Manager:                                                          *
 *      Ms. Rong XIONG ([e-mail])                            *
 *                                                                         *
 *   If you met any problems or you have something to discuss about        *
 *   ZJUBase. Please feel free to contact us through EMails given below.   *
 *                                                                         *
 *   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; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   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 General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/

#include "gamestate.h"
#include "types.h"
#include <iostream>
using namespace std;

#define CALL_MEMBER_FN(object,ptrToMember)  ((object).*(ptrToMember))

GameState::GameState() :
    mTeamLeft("team_left"),
    mTeamRight("team_right"),
    mHalf(-1),
    mCycle(0),
    mTime(0.0),
    mScoreLeft(0),
    mScoreRight(0),
    mPlayMode(-1)
{
    ResetBall();
    ResetPlayers();
    ResetFlags();
    SetupProcessMap();
    SetupFlagMap();
    SetupPlaymodeMap();

    mFieldWidth = DEFAULT_FIELD_WIDTH;
    mFieldLength = DEFAULT_FIELD_LENGTH;
    mFieldHeight = DEFAULT_FIELD_HEIGHT;
    mGoalWidth = DEFAULT_GOAL_WIDTH;
    mGoalDepth = DEFAULT_GOAL_DEPTH;
    mGoalHeight = DEFAULT_GOAL_HEIGHT;
    mBorderSize = DEFAULT_BORDER_SIZE;
    mLineWidth = DEFAULT_LINE_WIDTH;
    mFinished = false;

    mPanTiltVector[0] = mPanTiltVector[1] = Vector3(0, 0, 0);
}

GameState::~GameState()
{
}

std::string
GameState::PlayMode2Str(int mode) const
{
    if (mode < 0 || mode >= mPlaymodes.size())
    {
        return "playmode_unknown";
    }
    return mPlaymodes[mode];
}

void
GameState::ProcessInput(Predicate& pred)
{
    TProcessMap::const_iterator i = mProcessMap.find(pred.name);
    if (i != mProcessMap.end()) {
        CALL_MEMBER_FN(*this,i->second)(pred);
    }
}

void
GameState::ProcessInput(vector<Predicate>& plist)
{
    static int last = -1;
    if (last == mCycle) {
        return;
    }
    if (mCycle < 0 || mCycle >= plist.size()) {
        return;
    }
    TProcessMap::const_iterator i = mProcessMap.find(plist[mCycle].name);
    if (i != mProcessMap.end()) {
        CALL_MEMBER_FN(*this,i->second)(plist[mCycle]);
    }
    last = mCycle;
/*
    for (PredicateList::TList::const_iterator iter = plist->begin();
         iter != plist->end();
         ++iter)
    {
        const Predicate& predicate = (*iter);

        TProcessMap::const_iterator i = mProcessMap.find(predicate.name);
        if (i != mProcessMap.end())
        {
            CALL_MEMBER_FN(*this,i->second)(predicate);
        }
    }
*/
}

string
GameState::GetTeamnameLeft() const
{
    return mTeamLeft;
}
void
GameState::SetTeamnameLeft(const string& name)
{
    mTeamLeft = name;
}

string
GameState::GetTeamnameRight() const
{
    return mTeamRight;
}
void
GameState::SetTeamnameRight(const string& name)
{
    mTeamRight = name;
}

int
GameState::GetHalf() const
{
    return mHalf;
}

void
GameState::SetCycle(int nCycle)
{
    mCycle = nCycle;
}

int
GameState::GetCycle() const
{
    return mCycle;
}

double
GameState::GetTime() const
{
    return mTime;
}

void
GameState::SetTime(double t)
{
    mTime = t;
}

int
GameState::GetScoreLeft() const
{
    return mScoreLeft;
}

int
GameState::GetScoreRight() const
{
    return mScoreRight;
}

int
GameState::GetPlayMode() const
{
    return mPlayMode;
}

void
GameState::SetPlayMode(int mode)
{
    mPlayMode = mode;
}

bool
GameState::GetPlayer(int index,
                     Vector3& pos, TTeamIndex& side, int& unum, double& size) const
{
//    if (index < 0 || index >= mSeenPlayers.size() || !mSeenPlayers[index])
    if (index < 0 || index >= mPlayers.size()) {
        pos.z = 100;
        side = -1;
        unum = -1;
        size = DEFAULT_AGENT_RADIUS;
        return false;
    }

    pos = mPlayers[index].mPos;
    side = mPlayers[index].mSide;
    unum = mPlayers[index].mUnum;
    size = DEFAULT_AGENT_RADIUS;
    return true;
}

bool
GameState::SetPlayer(int index,
                     Vector3& pos, TTeamIndex& side, int& unum)
{
    if (index < 0 || index >= 22)
        return false;

    if (index >= mPlayers.size()) {
        PlayerInfo noPlayer;
        noPlayer.mUnum = -1;
        noPlayer.mPos.z = 100;
        mPlayers.resize(index + 1, noPlayer);
    }

    mPlayers[index].mPos = pos;
    mPlayers[index].mSide = side;
    mPlayers[index].mUnum = unum;
    return true;
}

bool
GameState::SetPanTilt(double panAngle, double tiltAngle, const Vector3& myPos)
{
    panAngle = panAngle * pi / 180.0;
    tiltAngle = tiltAngle * pi / 180.0;
    mPanTiltVector[0] = myPos;
    mPanTiltVector[1].x = cos(tiltAngle) * cos(panAngle);
    mPanTiltVector[1].y = cos(tiltAngle) * sin(panAngle);
    mPanTiltVector[1].z = sin(tiltAngle);
    mPanTiltVector[1] += mPanTiltVector[0];
    return true;
}

bool
GameState::GetPanTilt(double& panAngle, double& tiltAngle) const
{
    Vector3 vec = (mPanTiltVector[1].x - mPanTiltVector[0].x,
        mPanTiltVector[1].y - mPanTiltVector[0].y,
        mPanTiltVector[1].z - mPanTiltVector[0].z);
    double len = vec.mod();
    if (len < eps)
        return false;
    tiltAngle = asin(vec.z / len);
    len *= cos(tiltAngle);
    panAngle = acos(vec.x / len);
    if (vec.y < 0) panAngle = -panAngle;
    return true;
}

bool
GameState::GetPanTilt(Vector3& start, Vector3& end) const
{
    Vector3 vec = (mPanTiltVector[1].x - mPanTiltVector[0].x,
        mPanTiltVector[1].y - mPanTiltVector[0].y,
        mPanTiltVector[1].z - mPanTiltVector[0].z);
    double len = vec.mod();
    if (len < eps)
        return false;
    start = mPanTiltVector[0];
    end = mPanTiltVector[1];
    return true;
}

bool
GameState::GetAck(std::string &ack)
{
    if(mAck.empty()){return false;}
    ack = mAck;
    return true;
}

bool
GameState::GetPlayerMessage(int index, std::string& message) const
{
    if (index < 0 || index >= mSeenPlayers.size() || !mSeenPlayers[index])
        return false;

    if (mPlayers[index].mMessage.empty())
        return false;

    message = mPlayers[index].mMessage;
    return true;
}

bool
GameState::GetBall(Vector3& pos) const
{
    if (!mSeenBall) return false;
    pos = mBall;
    return true;
}

bool
GameState::SetBall(Vector3& pos)
{
    mBall = pos;
    mSeenBall = true;
    return true;
}

bool
GameState::GetBall(Vector3& pos, double& size) const
{
    if (!mSeenBall) return false;
    pos = mBall;
    size = DEFAULT_BALL_RADIUS;
    return true;
}

bool
GameState::GetFlag(EFlagType id, Vector3& pos) const
{
    std::map<EFlagType, bool>::const_iterator i = mSeenFlags.find(id);
    if (i == mSeenFlags.end() || i->second == false) return false;

    std::map<EFlagType, Vector3>::const_iterator j = mFlags.find(id);
    if (j == mFlags.end()) return false;
    pos = j->second;
    return true;
}

std::string
GameState::GetFlagName(EFlagType id) const
{
    TFlagNameMap::const_iterator i = mFlagNameMap.find(id);
    if (i == mFlagNameMap.end()) return std::string();
    return i->second;
}

void
GameState::ResetBall()
{
    mSeenBall = false;
}

void
GameState::ResetPlayers()
{
    for (std::vector<bool>::iterator i = mSeenPlayers.begin();
         i != mSeenPlayers.end(); ++i)
    {
        *i = false;
    }
}

void
GameState::ResetFlags()
{
    for (int i=0; i<eILLEGAL; ++i)
    {
        mSeenFlags[static_cast<EFlagType>(i)] = false;