Modules/BehaviorControl/CommonXabsl2Symbols/RoboCupGameManagerSymbols.cpp

Go to the documentation of this file.

/** 
* @file RoboCupGameManagerSymbols.cpp
*
* Implementation of class RoboCupGameManagerSymbols.
*
* @author Matthias Jüngel
*/

#include "RoboCupGameManagerSymbols.h"


RoboCupGameManagerSymbols::RoboCupGameManagerSymbols(const BehaviorControlInterfaces& interfaces)
: BehaviorControlInterfaces(interfaces),
lastGameControlDataState(GameControlData::initial),
timeWhenOwnTeamScored(0), lastOwnScore(0),
timeWhenOpponentTeamScored(0), lastOpponentScore(0), currentState(GameControlData::initial)
{
}


void RoboCupGameManagerSymbols::registerSymbols(Xabsl2Engine& engine)
{
  // "game.state"
  engine.registerEnumeratedInputSymbol("game.state",this,
    (int (Xabsl2FunctionProvider::*)())&RoboCupGameManagerSymbols::getState);
  engine.registerEnumeratedInputSymbolEnumElement("game.state","game.state.initial",GameControlData::initial);
  engine.registerEnumeratedInputSymbolEnumElement("game.state","game.state.ready",GameControlData::ready);
  engine.registerEnumeratedInputSymbolEnumElement("game.state","game.state.set",GameControlData::set);
  engine.registerEnumeratedInputSymbolEnumElement("game.state","game.state.playing",GameControlData::playing);
  engine.registerEnumeratedInputSymbolEnumElement("game.state","game.state.finished",GameControlData::finished);
  engine.registerEnumeratedInputSymbolEnumElement("game.state","game.state.penalized",42); //HACK !
  // "game.current-state"
  engine.registerEnumeratedOutputSymbol("game.current-state",(int*) &currentState);
  engine.registerEnumeratedOutputSymbolEnumElement("game.current-state","game.current-state.initial",GameControlData::initial);
  engine.registerEnumeratedOutputSymbolEnumElement("game.current-state","game.current-state.ready",GameControlData::ready);
  engine.registerEnumeratedOutputSymbolEnumElement("game.current-state","game.current-state.set",GameControlData::set);
  engine.registerEnumeratedOutputSymbolEnumElement("game.current-state","game.current-state.playing",GameControlData::playing);
  engine.registerEnumeratedOutputSymbolEnumElement("game.current-state","game.current-state.finished",GameControlData::finished);
  engine.registerEnumeratedOutputSymbolEnumElement("game.current-state","game.current-state.penalized",42); //HACK !
  // "game.kickoff"
  engine.registerEnumeratedInputSymbol("game.kickoff",this,
    (int (Xabsl2FunctionProvider::*)())&RoboCupGameManagerSymbols::getKickoff);
  engine.registerEnumeratedInputSymbolEnumElement("game.kickoff","game.kickoff.invalid",GameControlData::undefinedTeam);
  engine.registerEnumeratedInputSymbolEnumElement("game.kickoff","game.kickoff.own",GameControlData::ownTeam);
  engine.registerEnumeratedInputSymbolEnumElement("game.kickoff","game.kickoff.opponent",GameControlData::opponentTeam);
  // "game.team-color"
  engine.registerEnumeratedInputSymbol("game.team-color",this,
    (int (Xabsl2FunctionProvider::*)())&RoboCupGameManagerSymbols::getTeamColor);
  engine.registerEnumeratedInputSymbolEnumElement("game.team-color","red",Player::red);
  engine.registerEnumeratedInputSymbolEnumElement("game.team-color","blue",Player::blue);
  // "game.set-team-color"
  engine.registerEnumeratedOutputSymbol("game.set-team-color",this,
    (void (Xabsl2FunctionProvider::*)(int))&RoboCupGameManagerSymbols::setTeamColor);
  engine.registerEnumeratedOutputSymbolEnumElement("game.set-team-color","red",Player::red);
  engine.registerEnumeratedOutputSymbolEnumElement("game.set-team-color","blue",Player::blue);
  // "game.own-team-scored"
  engine.registerBooleanInputSymbol("game.own-team-scored",this,
    (bool (Xabsl2FunctionProvider::*)())&RoboCupGameManagerSymbols::getOwnTeamScored);
  // "game.opponent-team-scored"
  engine.registerBooleanInputSymbol("game.opponent-team-scored",this,
    (bool (Xabsl2FunctionProvider::*)())&RoboCupGameManagerSymbols::getOpponentTeamScored);
  // "game.own-score"
  engine.registerDecimalInputSymbol("game.own-score",this,
    (double (Xabsl2FunctionProvider::*)())&RoboCupGameManagerSymbols::getOwnScore);
  // "game.opponent-score"
  engine.registerDecimalInputSymbol("game.opponent-score",this,
    (double (Xabsl2FunctionProvider::*)())&RoboCupGameManagerSymbols::getOpponentScore);
  // "game.time-since-last-message"
  engine.registerDecimalInputSymbol("game.time-since-last-message",this,
    (double (Xabsl2FunctionProvider::*)())&RoboCupGameManagerSymbols::getTimeSinceLastMessage);
  // self symbols
}

void RoboCupGameManagerSymbols::update()
{
  /* If the robot is in ready now and was playing or penalized before */
  if ((gameControlData.data.state == GameControlData::ready)&&
    ((lastGameControlDataState == GameControlData::playing)))
  {
    if (gameControlData.getOwnTeam().score > (uint32)lastOwnScore) 
    {
      timeWhenOwnTeamScored = SystemCall::getCurrentSystemTime();
    }
    if (gameControlData.getOpponentTeam().score > (uint32)lastOpponentScore)
    {
      timeWhenOpponentTeamScored = SystemCall::getCurrentSystemTime();
    }
  }
  lastOwnScore = gameControlData.getOwnTeam().score;
  lastOpponentScore = gameControlData.getOpponentTeam().score;
  lastGameControlDataState = gameControlData.data.state;
  
  if (getTimeSinceLastMessage() < 500) // why only then....
  {
    getPlayer().setTeamColor(
      gameControlData.getOwnTeam().teamColour == TEAM_RED ? Player::red : Player::blue);
  }
}

void RoboCupGameManagerSymbols::setTeamColor(int teamColor)
{
  getPlayer().setTeamColor((Player::teamColor)teamColor);
}

int RoboCupGameManagerSymbols::getState()
{
  // Small hack so that the old Behavior works with the new game-controller.
  // Should be done better in the future.
  if (gameControlData.getRobot().penalty != GameControlData::notPenalized) 
  {
    return (42); // HACK !
  }
  return (int)gameControlData.data.state;
}

int RoboCupGameManagerSymbols::getKickoff()
{
  return (int)gameControlData.getKickoffTeam();
}

int RoboCupGameManagerSymbols::getTeamColor() 
{ 
  return (int)(getPlayer().getTeamColor()); 
}

bool RoboCupGameManagerSymbols::getOwnTeamScored()
{
  return (SystemCall::getTimeSince(timeWhenOwnTeamScored) < 5000);
}

bool RoboCupGameManagerSymbols::getOpponentTeamScored()
{
  return (SystemCall::getTimeSince(timeWhenOpponentTeamScored) < 5000);
}

double RoboCupGameManagerSymbols::getOwnScore()
{
  return (double)gameControlData.getOwnTeam().score;
}

double RoboCupGameManagerSymbols::getOpponentScore()
{
  return (double)gameControlData.getOpponentTeam().score;
}

double RoboCupGameManagerSymbols::getTimeSinceLastMessage()
{
  return (double)SystemCall::getTimeSince(gameControlData.timeStamp);
}

---