soccertypes.c

机器足球2D比赛程序 对trlen_base_2002的改进

/*! \file SoccerTypes.C
<pre>
<b>File:</b>          SoccerTypes.C
<b>Project:</b>       Robocup Soccer Simulation Team: UvA Trilearn
<b>Authors:</b>       Jelle Kok
<b>Created:</b>       28/11/2000
<b>Last Revision:</b> $ID$
<b>Contents:</b>      This file contains the different enumerations and
               constants that are important in the Soccer Server.
               Furthermore it contains the class SoccerCommand which is
               used to denote the different possible soccer commands and
               the class SoccerTypes that contains all kind of static
               methods to translate text strings that are received from
               the server into the soccer types (=enumerations) that
               are defined here.  Finally it contains the Time class which
               holds a two-tuple that represents the time in the soccer server.

<hr size=2>
<h2><b>Changes</b></h2>
<b>Date</b>             <b>Author</b>          <b>Comment</b>
28/11/2000       Jelle Kok       Initial version created
</pre>
*/

#include <iostream>       // needed for outputsteam in showcerr
#include <stdio.h>        // needed for sprintf
#ifdef Solaris
  #include <strings.h>    // needed for strncmp
#else
  #include <string.h>     // needed for strncmp
#endif

#include "SoccerTypes.h"
#include "Parse.h"


/******************************************************************************/
/********************** CLASS TIME ********************************************/
/******************************************************************************/

/*! This is the constructor for the Time class, it receives two arguments. The
    actual time and how long the time has stopped.
    \param iTime actual time
    \param iStopped number of cycles time stopped */
Time::Time( int iTime, int iStopped )
{
  m_iTime    = iTime;
  m_iStopped = iStopped;
}

/*! This method updates the time to 'iTime'. When the actual time was already
    'iTime' the current time is kept unchanged and the time stopped is raised
    with one. Otherwise the actual time is changed to 'iTime' and the stopped
    time is set to 0.
    \param iTime new time
    \return boolean indicating whether update was successful */
bool Time::updateTime( int iTime )
{
  if( m_iTime == iTime )
    m_iStopped++;
  else
  {
    m_iTime    = iTime;
    m_iStopped = 0;
  }
  return true;
}

/*! This methods sets the stopped time, which denotes the number of cycles time
    stood still.
    \param iTime new stopped time
    \return boolean indicating whether update was successful */
bool Time::setTimeStopped( int iTime )
{
  m_iStopped = iTime;
  return true;
}

/*! This method returns the actual time, that is the number of cycles that have
    passed.
    \return actual time. */
int Time::getTime( )
{
  return m_iTime;
}

/*! This method returns the time the time has stopped, that is the number of
    cycles the time stood on the current value.
    \return stopped time */
int Time::getTimeStopped( )
{
  return m_iStopped;
}

/*! This method returns the time difference between two time objects.
    \param t Time with which current time should be compared
    \return time difference */
int Time::getTimeDifference( Time t )
{
  if( getTime() < t.getTime() )
    return getTime() - t.getTime() - t.getTimeStopped();
  else if( getTime() == t.getTime() )
    return getTimeStopped() - t.getTimeStopped();
  else
    return getTime() - t.getTime();
}

/*! This method returns a boolean value indicating whether the time currently is
    stopped.
    \return boolean indicating whether the time currently is stopped */
bool Time::isStopped( )
{
  return m_iStopped != 0;
}

/*! This method returns a new time class denoting the time when 'iCycles' are
    added to the current time.
    There are different situations possible. When the added time is positive and
    the time stands still, the cycles are added to the stopped time, otherwise
    they are added to the actual time. When the added time is negative and the
    time stands still, the cycles are subtracted from the stopped time.
    Otherwise the time is subtracted from the actual time.
    \param iCycles denotes the time that should be added (when negative
    subtracted) to the current time
    \return new time object with 'iCycles' added to the current time. 'iCycles'
    can be negative in which case a subtraction is performed. */
Time Time::getTimeAddedWith( int iCycles )
{
  int iTime    = getTime();
  int iStopped = getTimeStopped();

  if( iCycles > 0 )                            // add cycles
  {
    if( iStopped > 0 )                         // time stopped
      iStopped += iCycles;                     // add it to stopped cycles
    else
      iTime    += iCycles;                     // otherwise add to normal time
  }
  else                                         // subtract cycles
  {
    if( iStopped > 0 && iStopped >= iCycles)   // time stopped and enough time
      iStopped += iCycles;                     // subtract cycle (iCycles=neg)
    else if( iStopped > 0 )                    // stopped but not enough time
    {
      iStopped = 0;                            // take as many as possible
      iCycles += iStopped;
      iTime   += iCycles;                      // and take rest from m_iTime
    }
    else                                       // time not stopped
      iTime   += iCycles;                      // take all from m_iTime
    if( iTime < 0 )
      iTime = 0;                               // negative time not possible
  }
  return Time( iTime, iStopped );
}

/*! This method adds 'iCycles' to the current time. The current values are
    updated. The method getTimeAddedWith is used to calculated the new time.
    \param iCycles time added to the current time
    \return boolean indicating whether update was successful */
bool Time::addToTime( int iCycles )
{
  *this = getTimeAddedWith( iCycles );
  return true;
}

/*! This method prints the time to the specified output stream. Time is printed
    as the two tuple (t,s) where t denotes the actual time and s the number of
    stopped cycles.
    \param os output stream to which output is written (default cout) */
void Time::show( ostream &os )
{
  os << "(" << getTime() << "," << getTimeStopped() << ")";
}

/*! This method returns the time as if 'i' cycles would be added to the current
    time. The method getTimeAddedWith is used for this. No changes are made to
    the current object.
    \param iCycles denotes the time that should be added to the current time
    \return new time object with 'iCycles' added to the current time */
Time Time::operator + ( const int &i )
{
  return getTimeAddedWith( i );
}

/*! This method returns the result of adding time 't' to the current
    time. No changes are made to the current object.
    It is defined by (t1,s1) + (t2,s2) = (t1+t2,s2). The stopped time of the
    first time tuple is neglected, since this has already been passed.
    \param t Time object that should be added to the current time
    \return new time object with 't' added to the current time */
Time Time::operator + ( Time t )
{
  return Time( getTime() + t.getTime(), t.getTimeStopped() );
}

/*! This method returns the time as if 'i' cycles would be subtracted from the
    current time. The method getTimeAddedWith is used for this. No changes are
    made to the current object.
    \param iCycles denotes the time that should be subtracted from the time
    \return new time object with 'iCycles' subracted  */
Time Time::operator - ( const int &i )
{
  return getTimeAddedWith( -i );
}

/*! This method returns the result the difference between the two times and
    is equal to the method getTimeDifference.
    \param t Time object that should be subtracted from the current time
    \return new time object with 't' subtracted from the current time */
int Time::operator - ( Time t )
{
  return getTimeDifference( t );
}

/*! This method returns a new time object (i,0). The argument 'i' is thus
    denoted as the actual time.
    \param i new time
    \return time object */
void Time::operator = ( const int &i )
{
  updateTime( i );
  setTimeStopped( 0 );
}

/*! This method updates the time by adding 'i' cycles to the current
    time. The method addToTime is used for this.
    \param i denotes the time that should be added to the current time */
void Time::operator += ( const int &i )
{
  addToTime( i );
}

/*! This method updates the time by adding the time 't' to the current
    time.
    It is defined by (t1,s1) + (t2,s2) = (t1+t2,s2). The stopped time of the
    first time tuple is neglected, since this has already been passed.
    \param t Time object that should be added to the current time */
void Time::operator += ( Time t )
{
  updateTime    ( getTime() + t.getTime() );
  setTimeStopped( t.getTimeStopped()      );
}

/*! This method updates the time by subtractign 'i' cycles from the
    current time. The method addToTime is used for this with '-i' as
    its argument.
    \param i denotes the time that should be subtracted */
void Time::operator -= ( const int &i )
{
  addToTime( -i );
}

/*! This method updates the time by subtracting time 't' from the current
    time. It is defined by (t1,s1) + (t2,s2) = (t1-t2,0). The stopped time is
    set to zero.
    \param t Time object that should be subtracted from the current time */
void Time::operator -= ( Time t )
{
  updateTime    ( getTime() - t.getTime() );
  setTimeStopped( 0                       );
}


/*! This method returns a boolean indicating whether the current time is inequal
    to the time specified by the integer 'i'. 'i' is first converted to the time
    object (i,0). When the time difference returned by getTimeDifference between
    these two time objects is inequal to zero true is returned, false otherwise
    \param i actual time with which current time should be compared
    \return bool indicating whether current time equals specified time */
bool Time::operator != ( const int &i )
{
  return getTimeDifference( Time(i, 0) ) != 0;
}

/*! This method returns a boolean indicating whether the current time is inequal
    to the time t. When the time difference returned by getTimeDifference
    between these two time objects is inequal to zero true is returned, false
    otherwise.
    \param t time with which current time should be compared
    \return bool indicating whether current time equals specified time */
bool Time::operator != ( Time t )
{
  return getTimeDifference( t ) != 0;
}

/*! This method returns a boolean indicating whether the current time equals
    the time as specified by the integer 'i'. 'i' is first converted to the time
    object (i,0). When the time difference returned by getTimeDifference between
    these two time objects equals zero, true is returned, false otherwise
    \param i actual time with which current time should be compared
    \return bool indicating whether current time equals specified time */
bool Time::operator == ( const int &i )
{
  return !( *this != i );
}

/*! This method returns a boolean indicating whether the current time equals
    the time t. When the time difference returned by getTimeDifference between
    these two time objects equals zero, true is returned, false otherwise
    \param t time with which current time should be compared
    \return bool indicating whether current time equals specified time */
bool Time::operator == ( Time t )
{
  return !( *this != t );
}

/*! This method returns a boolean indicating whether the current time is smaller
    than the time t. When the time difference returned by getTimeDifference
    is smaller than zero, true is returned, false otherwise
    \param t time with which current time should be compared
    \return bool indicating whether current time is smaller than given time */
bool Time::operator <  ( Time t )
{
  return getTimeDifference( t ) < 0;
}

/*! This method returns a boolean indicating whether the current time is smaller
    than the time denoted by the integer 'i'. Herefore first a time object (i,0)
    is created.
    \param t time with which current time should be compared
    \return bool indicating whether current time is smaller than given time */
bool Time::operator <  ( const int  &i )
{
  return Time( i, 0 ) >= *this ;
}

/*! This method returns a boolean indicating whether the current time is smaller
    than or equal to the time t.
    \param t time with which current time should be compared
    \return bool indicating whether current time is smaller to or equal
     than 't' */
bool Time::operator <= ( Time t )
{
  return ( *this < t ) || (*this == t );
}