Representations/RoboCup/GameControlData.cpp

Go to the documentation of this file.

/**
* @file GameControlData.cpp
*
* Implementation of class GameControlData.
*
* @author Martin Loetzsch
*/

#include "GameControlData.h"
#include "Platform/SystemCall.h"
#include "Tools/Debugging/Debugging.h"


GameControlData::GameControlData()
: timeStamp(0)
, switchOff(false)
{
  strncpy(data.header,STRUCT_HEADER,4);
  data.version = STRUCT_VERSION;
  data.state = (int)initial;
  data.firstHalf = 0;
  data.kickOffTeam = 0;
  data.secsRemaining = 10 * 60;
  data.dropInTeam = TEAM_RED;
  data.dropInTime = 0;

  for (int team=0; team < 2; team++)
  {
    data.teams[team].teamNumber = team;
    data.teams[team].teamColour = team;
    data.teams[team].score = 0;
    for (int player=0; player < 4; player++)
    {
      data.teams[team].players[player].penalty = (int)notPenalized;
    }
  }
}

unsigned int GameControlData::getOwnTeamNumber(Player player) const
{
  if (data.teams[0].teamNumber == (uint32)player.getGameControllerTeamNumber()) return 0;
  return 1;
}

unsigned int GameControlData::getOpponentTeamNumber(Player player) const
{
  if (data.teams[0].teamNumber == (uint32)player.getGameControllerTeamNumber()) return 1;
  return 0;
}
const TeamInfo& GameControlData::getOwnTeam(Player player) const
{
  return data.teams[getOwnTeamNumber(player)];
}

TeamInfo& GameControlData::getOwnTeam(Player player)
{
  return data.teams[getOwnTeamNumber(player)];
}

const TeamInfo& GameControlData::getOpponentTeam(Player player) const
{
  return data.teams[getOpponentTeamNumber(player)];
}

TeamInfo& GameControlData::getOpponentTeam(Player player)
{
  return data.teams[getOpponentTeamNumber(player)];
}

GameControlData::KickoffTeam GameControlData::getKickoffTeam(Player player) const
{
   if (getOwnTeamNumber(player) == data.kickOffTeam)
   {
     return ownTeam;
   }
   else
   {
     return opponentTeam;
   }
}

GameControlData::Penalties GameControlData::getPenalty(Player player) const
{
   return (Penalties)(getRobot(player).penalty);
}


const RobotInfo& GameControlData::getRobot(Player player) const
{
  return (getOwnTeam(player).players[(int)player.getPlayerNumber()]);
}

RobotInfo& GameControlData::getRobot(Player player)
{
  return (getOwnTeam(player).players[(int)player.getPlayerNumber()]);
}

const TeamInfo& GameControlData::getTeamByNumber(int number) const
{
  if (data.teams[0].teamNumber == (uint32)number) return data.teams[0];
  return data.teams[1];
}

TeamInfo& GameControlData::getTeamByNumber(int number)
{
  if (data.teams[0].teamNumber == (uint32)number) return data.teams[0];
  return data.teams[1];
}

const TeamInfo& GameControlData::getTeamByColor(int color) const
{
  if (data.teams[0].teamColour == (uint32)color) return data.teams[0];
  return data.teams[1];
}

TeamInfo& GameControlData::getTeamByColor(int color)
{
  if (data.teams[0].teamColour == (uint32)color) return data.teams[0];
  return data.teams[1];
}

bool GameControlData::operator == (const GameControlData& other) 
{
  return memcmp(&data,&(other.data),sizeof(data)) == 0; // ist das so gewollt ?
}

const char* GameControlData::getPenaltyName(Penalties penalty) 
  {
    switch (penalty)
    {
    case notPenalized: return "no penalty";
    case illegalDefender: return "illegal defender";
    case illegalDefense: return "illegal defense";
    case obstruction: return "obstruction";
    case goaliePushing: return "goalie pushing";
    case playerPushing: return "field player pushing";
    case ballHolding: return "ball holding";
    case requestForPickup: return "request for pick-up";
    default: return "unknown penalty";
    }
  }

const char* GameControlData::getStateName(State state)
{
    switch (state)
    {
    case initial: return "initial";
    case ready: return "ready";
    case set: return "set";
    case playing: return "playing";
    case finished: return "finished";
    default: return "unknown state";
    }
 }
  

const char* GameControlData::getKickoffTeamName(KickoffTeam kickoffTeam)
{
  switch(kickoffTeam)
  {
      case ownTeam: return "own team";
      case opponentTeam: return "opponent team";
      default: return "unknown kickoff";
  }
}

In& operator>>(In& stream,GameControlData& gameControlData)
{
  if (gameControlData.switchOff)
  {
    stream.skip(sizeof(RoboCupGameControlData));
    return stream;
  }
  RoboCupGameControlData data;
  stream.read(&data,sizeof(RoboCupGameControlData));
  
  /* Copy GameControlData only if the Robot is in one of the two teams and has the right header-string*/
  if (  ((data.teams[0].teamNumber == (uint32)getPlayer().getGameControllerTeamNumber())  ||
         (data.teams[1].teamNumber == (uint32)getPlayer().getGameControllerTeamNumber())) && 
         (data.version == STRUCT_VERSION) &&
         (strncmp(data.header,STRUCT_HEADER,4) == 0))
  {
    gameControlData.data = data;
    gameControlData.timeStamp = SystemCall::getCurrentSystemTime();
  }

  return stream;
}

Out& operator<<(Out& stream, const GameControlData& gameControlData)
{
  stream.write(&gameControlData.data,sizeof(RoboCupGameControlData));
  return stream;
}

---