Main Page   Class Hierarchy   Compound List   File List   Compound Members   File Members  

SoccerTypes.C

Go to the documentation of this file.
00001 /*
00002 Copyright (c) 2000-2002, Jelle Kok, University of Amsterdam
00003 All rights reserved.
00004 
00005 Redistribution and use in source and binary forms, with or without 
00006 modification, are permitted provided that the following conditions are met:
00007 
00008 1. Redistributions of source code must retain the above copyright notice, this 
00009 list of conditions and the following disclaimer. 
00010 
00011 2. Redistributions in binary form must reproduce the above copyright notice, 
00012 this list of conditions and the following disclaimer in the documentation 
00013 and/or other materials provided with the distribution. 
00014 
00015 3. Neither the name of the University of Amsterdam nor the names of its 
00016 contributors may be used to endorse or promote products derived from this 
00017 software without specific prior written permission. 
00018 
00019 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 
00020 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
00021 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 
00022 DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE 
00023 FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 
00024 DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 
00025 SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 
00026 CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 
00027 OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
00028 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
00029 */
00054 #include <iostream.h>     // needed for outputsteam in showcerr
00055 #include <stdio.h>        // needed for sprintf
00056 #ifdef Solaris
00057   #include <strings.h>    // needed for strncmp
00058 #else
00059   #include <string.h>     // needed for strncmp
00060 #endif
00061 
00062 #include "SoccerTypes.h"
00063 #include "Parse.h"
00064 
00065 
00066 /******************************************************************************/
00067 /********************** CLASS TIME ********************************************/
00068 /******************************************************************************/
00069 
00074 Time::Time( int iTime, int iStopped )
00075 {
00076   m_iTime    = iTime;
00077   m_iStopped = iStopped;
00078 }
00079 
00086 bool Time::updateTime( int iTime )
00087 {
00088   if( m_iTime == iTime )
00089     m_iStopped++;
00090   else
00091   {
00092     m_iTime    = iTime;
00093     m_iStopped = 0;
00094   }
00095   return true;
00096 }
00097 
00102 bool Time::setTimeStopped( int iTime )
00103 {
00104   m_iStopped = iTime;
00105   return true;
00106 }
00107 
00111 int Time::getTime( )
00112 {
00113   return m_iTime;
00114 }
00115 
00119 int Time::getTimeStopped( )
00120 {
00121   return m_iStopped;
00122 }
00123 
00130 int Time::getTimeDifference( Time t )
00131 {
00132   if( getTime() < t.getTime() )
00133     return getTime() - t.getTime();
00134   else if( getTime() == t.getTime() )
00135     return getTimeStopped() - t.getTimeStopped();
00136   else
00137     return getTime() - t.getTime();
00138 }
00139 
00143 bool Time::isStopped( )
00144 {
00145   return m_iStopped != 0;
00146 }
00147 
00159 Time Time::getTimeAddedWith( int iCycles )
00160 {
00161   int iTime    = getTime();
00162   int iStopped = getTimeStopped();
00163 
00164   if( iCycles > 0 )                            // add cycles
00165   {
00166     if( iStopped > 0 )                         // time stopped
00167       iStopped += iCycles;                     // add it to stopped cycles
00168     else
00169       iTime    += iCycles;                     // otherwise add to normal time
00170   }
00171   else                                         // subtract cycles
00172   {
00173     if( iStopped > 0 && iStopped >= iCycles)   // time stopped and enough time
00174       iStopped += iCycles;                     // subtract cycle (iCycles=neg)
00175     else if( iStopped > 0 )                    // stopped but not enough time
00176     {
00177       iStopped = 0;                            // take as many as possible
00178       iCycles += iStopped;
00179       iTime   += iCycles;                      // and take rest from m_iTime
00180     }
00181     else                                       // time not stopped
00182       iTime   += iCycles;                      // take all from m_iTime
00183     if( iTime < 0 )
00184       iTime = 0;                               // negative time not possible
00185   }
00186   return Time( iTime, iStopped );
00187 }
00188 
00193 bool Time::addToTime( int iCycles )
00194 {
00195   *this = getTimeAddedWith( iCycles );
00196   return true;
00197 }
00198 
00203 void Time::show( ostream &os )
00204 {
00205   os << "(" << getTime() << "," << getTimeStopped() << ")";
00206 }
00207 
00213 Time Time::operator + ( const int &i )
00214 {
00215   return getTimeAddedWith( i );
00216 }
00217 
00224 Time Time::operator + ( Time t )
00225 {
00226   return Time( getTime() + t.getTime(), t.getTimeStopped() );
00227 }
00228 
00234 Time Time::operator - ( const int &i )
00235 {
00236   return getTimeAddedWith( -i );
00237 }
00238 
00243 int Time::operator - ( Time t )
00244 {
00245   return getTimeDifference( t );
00246 }
00247 
00252 void Time::operator = ( const int &i )
00253 {
00254   updateTime( i );
00255   setTimeStopped( 0 );
00256 }
00257 
00261 void Time::operator += ( const int &i )
00262 {
00263   addToTime( i );
00264 }
00265 
00271 void Time::operator += ( Time t )
00272 {
00273   updateTime    ( getTime() + t.getTime() );
00274   setTimeStopped( t.getTimeStopped()      );
00275 }
00276 
00281 void Time::operator -= ( const int &i )
00282 {
00283   addToTime( -i );
00284 }
00285 
00290 void Time::operator -= ( Time t )
00291 {
00292   updateTime    ( getTime() - t.getTime() );
00293   setTimeStopped( 0                       );
00294 }
00295 
00296 
00303 bool Time::operator != ( const int &i )
00304 {
00305   return getTimeDifference( Time(i, 0) ) != 0;
00306 }
00307 
00314 bool Time::operator != ( Time t )
00315 {
00316   return getTimeDifference( t ) != 0;
00317 }
00318 
00325 bool Time::operator == ( const int &i )
00326 {
00327   return !( *this != i );
00328 }
00329 
00335 bool Time::operator == ( Time t )
00336 {
00337   return !( *this != t );
00338 }
00339 
00345 bool Time::operator <  ( Time t )
00346 {
00347   return getTimeDifference( t ) < 0;
00348 }
00349 
00355 bool Time::operator <  ( const int  &i )
00356 {
00357   return Time( i, 0 ) >= *this ;
00358 }
00359 
00365 bool Time::operator <= ( Time t )
00366 {
00367   return ( *this < t ) || (*this == t );
00368 }
00369 
00376 bool Time::operator <= ( const int  &i )
00377 {
00378   return ( *this < i ) || (*this == i );
00379 }
00380 
00385 bool Time::operator >  ( Time t )
00386 {
00387   return !( *this <= t );
00388 }
00389 
00395 bool Time::operator >  ( const int  &i )
00396 {
00397   return !( *this <= i );
00398 }
00399 
00404 bool Time::operator >= ( Time t )
00405 {
00406   return !( *this < t );
00407 
00408 }
00409 
00416 bool Time::operator >= ( const int  &i )
00417 {
00418   return !( *this < i );
00419 }
00420 
00428 ostream& operator <<( ostream &os, Time t )
00429 {
00430   return os << "(" << t.getTime() << "," << t.getTimeStopped() << ")";
00431 }
00432 
00433 /******************************************************************************/
00434 /********************** CLASS SOCCERCOMMAND ***********************************/
00435 /******************************************************************************/
00436 
00437 
00447 SoccerCommand::SoccerCommand( CommandT com, double d1, double d2, double d3 )
00448 {
00449   // first initialize variables
00450   commandType = com;
00451   dPower      = UnknownDoubleValue;
00452   dAngle      = UnknownDoubleValue;
00453   va          = VA_ILLEGAL;
00454   vq          = VQ_ILLEGAL;
00455   iTimes      = 1;
00456   strcpy( str, "\0" );
00457   if( com == CMD_CHANGEVIEW )
00458     makeCommand( commandType, (ViewAngleT)d1, (ViewQualityT)d2 );
00459   else if( com != CMD_SAY )
00460     makeCommand( commandType, d1, d2, d3 );
00461 }
00462 
00467 SoccerCommand::SoccerCommand( CommandT com, char *msg )
00468 {
00469   makeCommand( com, msg )  ;
00470 }
00471 
00489 void SoccerCommand::makeCommand( CommandT com, double d1, double d2, double d3 )
00490 {
00491   // set the variables that have a meaning for the specified command type
00492   commandType = com;
00493   if( com == CMD_TURN || com == CMD_TURNNECK )
00494     dAngle = d1;
00495   else if( com == CMD_DASH )
00496     dPower = d1;
00497   else if( com == CMD_KICK )
00498   {
00499     dPower = d1;
00500     dAngle = d2;
00501   }
00502   else if( com == CMD_MOVE )
00503   {
00504     dX = d1;
00505     dY = d2;
00506     if( d3 != UnknownDoubleValue )
00507       dAngle = d3;
00508     else
00509       dAngle = 0;
00510   }
00511   else if( com == CMD_CATCH )
00512     dAngle = d1;
00513   else if( com == CMD_CHANGEPLAYER )
00514   {
00515     dX = d1;
00516     dY = d2;
00517   }
00518   else if( com == CMD_ATTENTIONTO )
00519   {
00520     dX = d1;
00521     dY = d2;
00522   }
00523 }
00524 
00529 void SoccerCommand::makeCommand( CommandT com, ViewAngleT v, ViewQualityT q )
00530 {
00531   commandType = com;
00532   if( com == CMD_CHANGEVIEW )
00533   {
00534     va = (ViewAngleT)  v;
00535     vq = (ViewQualityT)q;
00536   }
00537 }
00538 
00543 void SoccerCommand::makeCommand( CommandT com, char* msg )
00544 {
00545   commandType = com;
00546   if( com == CMD_SAY )
00547      strcpy( str, msg );
00548 }
00549 
00552 void SoccerCommand::show( ostream& os )
00553 {
00554   os << "time: " << time << " "; // can be illegal when not yet set in WM.
00555   switch( commandType )
00556   {
00557     case CMD_ILLEGAL:
00558       os << "illegal\n" ;
00559       break;
00560     case CMD_DASH:
00561       os << "dash " << dPower << " times: " << iTimes << endl;
00562       break;
00563     case CMD_TURN:
00564     case CMD_TURNNECK:
00565       if( commandType == CMD_TURN )
00566         os << "turn " << dAngle << endl;
00567       else
00568         os << "turn_neck " << " " << dAngle << endl;
00569       break;
00570      case CMD_CHANGEVIEW:
00571       os << "change_view " <<
00572               SoccerTypes::getViewAngleStr( va ) << " " <<
00573               SoccerTypes::getViewQualityStr( vq ) << endl;
00574       break;
00575     case CMD_CATCH:
00576       os << "catch " << dAngle << endl;
00577       break;
00578     case CMD_KICK:
00579       os << "kick " << dPower << " " << dAngle << endl;
00580       break;
00581     case CMD_MOVE:
00582       os << "move " << dX << " " << dY << " " << dAngle << endl;
00583       break;
00584     case CMD_SENSEBODY:
00585       os << "sense_body" << endl;
00586       break;
00587     case CMD_SAY:
00588       os << "say " << str << endl;
00589       break;
00590     case CMD_CHANGEPLAYER:
00591       os << "change_player " << (int)dX << " " << (int)dY << endl;
00592       break;
00593     case CMD_ATTENTIONTO:
00594       os << "attentionto " << (int)dX << " " << (int)dY << endl;
00595     default:
00596       os << "unknown" << endl;
00597       break;
00598   }
00599 }
00600 
00605 bool SoccerCommand::isIllegal( )
00606 {
00607   return commandType == CMD_ILLEGAL;
00608 }
00609 
00617 char*  SoccerCommand::getCommandString( char *str, ServerSettings *ss )
00618 {
00619   SS = ss;
00620   bool b = false;
00621   switch( commandType )
00622   {
00623     case CMD_DASH:        b = makeDashCommand(         str ); break;
00624     case CMD_TURN:        b = makeTurnCommand(         str ); break;
00625     case CMD_TURNNECK:    b = makeTurnNeckCommand(     str ); break;
00626     case CMD_CHANGEVIEW:  b = makeChangeViewCommand(   str ); break;
00627     case CMD_CATCH:       b = makeCatchCommand(        str ); break;
00628     case CMD_KICK:        b = makeKickCommand(         str ); break;
00629     case CMD_MOVE:        b = makeMoveCommand(         str ); break;
00630     case CMD_SENSEBODY:   b = makeSenseBodyCommand(    str ); break;
00631     case CMD_SAY:         b = makeSayCommand(          str ); break;
00632     case CMD_CHANGEPLAYER:b = makeChangePlayerCommand( str ); break;
00633     case CMD_ATTENTIONTO: b = makeAttentionToCommand(  str ); break;
00634     case CMD_ILLEGAL:    str[0] = '\0';                       break;
00635     default:
00636       cerr << "(ActHandler::makeCommandString) Unkown command!"<<endl;
00637 
00638     if( b == false )                       // if string could not be created
00639     {
00640       commandType = CMD_ILLEGAL;
00641       str[0] = '\0';                       // create the empty string
00642     }
00643   }
00644   return str;
00645 }
00646 
00653 bool SoccerCommand::makeCatchCommand( char *str  )
00654 {
00655   if( SS->getMinMoment( ) <= dAngle && dAngle <= SS->getMaxMoment( ) )
00656     sprintf( str, "(catch %d)", (int)dAngle );
00657   else
00658   {
00659     fprintf(stderr,
00660      "(SoccerCommand::makeCatchCommand) angle %f out of bounds\n",dAngle);
00661     return false;
00662   }
00663   return true;
00664 }
00665 
00672 bool SoccerCommand::makeChangeViewCommand( char *str  )
00673 {
00674   if( va != VA_ILLEGAL && vq != VQ_ILLEGAL )
00675     sprintf( str,"(change_view %s %s)", SoccerTypes::getViewAngleStr  ( va ),
00676                                         SoccerTypes::getViewQualityStr( vq ) );
00677   else
00678   {
00679     fprintf( stderr,
00680        "(SoccerCommand::makeChangeViewCommand) wrong arguments %s %s\n",
00681                              SoccerTypes::getViewAngleStr  ( va ),
00682                              SoccerTypes::getViewQualityStr( vq )  );
00683     return false;
00684   }
00685   return true;
00686 }
00687 
00694 bool SoccerCommand::makeDashCommand( char *str  )
00695 {
00696   if( SS->getMinPower() <= dPower && dPower <= SS->getMaxPower() )
00697     sprintf( str,"(dash %d)", (int)dPower );
00698   else
00699   {
00700     fprintf( stderr, 
00701         "(SoccerCommand::makeDashCommand) power %d out of bounds (%d,%d)\n",
00702         (int)dPower, SS->getMinPower(), SS->getMaxPower() );
00703     dPower = 0.0;
00704     sprintf( str, "(dash 0)" );
00705     return false;
00706   }
00707   return true;
00708 }
00709 
00716 bool SoccerCommand::makeKickCommand( char *str  )
00717 {
00718   if( SS->getMinPower( )  <= dPower && dPower <= SS->getMaxPower( ) &&
00719       SS->getMinMoment( ) <= dAngle && dAngle <= SS->getMaxMoment( ) )
00720     sprintf( str,"(kick %d %d)", (int)dPower, (int)dAngle );
00721   else
00722   {
00723     fprintf(stderr,
00724            "(SoccerCommand::makeKickCommand) one argument %d or %d is wrong\n",
00725                     (int)dPower, (int)dAngle );
00726     return false;
00727   }
00728   return true;
00729 }
00730 
00737 bool SoccerCommand::makeMoveCommand( char *str  )
00738 {
00739   if( -PITCH_LENGTH/2 - PITCH_MARGIN <= dX &&
00740        PITCH_LENGTH/2 + PITCH_MARGIN >= dX &&
00741       -PITCH_WIDTH/2  - PITCH_MARGIN <= dY &&
00742        PITCH_WIDTH/2  + PITCH_MARGIN >= dY   )
00743     sprintf( str,"(move %d %d)", (int)dX, (int)dY);
00744   else
00745   {
00746     fprintf( stderr, 
00747          "(SoccerCommand::makeMoveCommand) one argument %d or %d is wrong\n",
00748                   (int)dX, (int)dY) ;
00749     return false;
00750   }
00751   return true;
00752 }
00753 
00760 bool SoccerCommand::makeSayCommand( char *str_com  )
00761 {
00762   if( str != NULL && str[0] != '\0' )
00763     sprintf( str_com, "(say %s)", str );
00764   else
00765   {
00766     fprintf( stderr, "(SoccerCommand::makeSayCommand) no string filled in\n" );
00767     return false;
00768   }
00769   return true;
00770 }
00771 
00777 bool SoccerCommand::makeSenseBodyCommand( char *str  )
00778 {
00779   sprintf( str,"(sense_body)" );
00780   return true;
00781 }
00782 
00789 bool SoccerCommand::makeTurnCommand( char *str  )
00790 {
00791   if( SS->getMinMoment( ) <= dAngle && dAngle <= SS->getMaxMoment( ) )
00792     sprintf( str,"(turn %d)", (int)dAngle );
00793   else
00794   {
00795     fprintf( stderr,
00796       "(SoccerCommand::makeTurnCommand) argument %d incorrect (%d, %d)\n",
00797       (int)dAngle, SS->getMinMoment( ), SS->getMaxMoment( ) );
00798     dAngle = 0.0;
00799     sprintf( str, "(turn 0)" );
00800     return false;
00801   }
00802   return true;
00803 }
00804 
00811 bool SoccerCommand::makeTurnNeckCommand( char *str  )
00812 {
00813   if( SS->getMinNeckMoment( ) <= (int)dAngle &&
00814       (int)dAngle             <= SS->getMaxNeckMoment( ) )
00815     sprintf( str,"(turn_neck %d)", (int)dAngle );
00816   else
00817   {
00818     fprintf( stderr,
00819        "(SoccerCommand::makeTurnNeckCommand) argument %d is wrong\n",
00820                                                      (int)dAngle );
00821     dAngle = 0.0;
00822     sprintf( str, "(turn_neck 0)" );
00823     return false;
00824   }
00825   return true;
00826 }
00827 
00837 bool SoccerCommand::makeChangePlayerCommand( char *str  )
00838 {
00839   if( (int)dX > 0  && (int)dX <= MAX_TEAMMATES &&
00840       (int)dY >= 0 && (int)dY < MAX_HETERO_PLAYERS  )
00841     sprintf( str,"(change_player_type %d %d)", (int)dX, (int)dY );
00842   else
00843   {
00844     fprintf( stderr,
00845     "(SoccerCommand::makeChangePlayerCommand) argument %d or %d is wrong\n",
00846                                                (int)dX, (int)dY  );
00847     return false;
00848   }
00849   return true;
00850 }
00851 
00862 bool SoccerCommand::makeAttentionToCommand( char *str  )
00863 {
00864   char strTeam[10];
00865   if( dY < 0 )
00866   {
00867     sprintf( str, "(attentionto off)" );
00868     return true;
00869   }
00870     
00871   if( dX < 0 )
00872     strcpy( strTeam, "opp" );
00873   else
00874     strcpy( strTeam, "our" );
00875     
00876   if( (int)dY > 0  && (int)dY <= MAX_TEAMMATES )
00877     sprintf( str,"(attentionto %s %d)", strTeam, (int)dY );
00878   else
00879   {
00880     fprintf( stderr,
00881      "(SoccerCommand::makeAttentionToCommand) argument %s or %d is wrong\n",
00882                                                strTeam, (int)dY  );
00883     return false;
00884   }
00885   return true;
00886 }
00887 
00888 /******************************************************************************/
00889 /********************** CLASS SOCCERTYPES *************************************/
00890 /******************************************************************************/
00891 
00896 const char * ObjectNames[] =
00897 {
00898 "(b)", "(g l)", "(g r)", "(g ?)", "(l l)", "(l r)", "(l b)", "(l t)", "(f l t)",    
00899 "(f t l 50)", "(f t l 40)", "(f t l 30)", "(f t l 20)", "(f t l 10)", "(f t 0)",
00900 "(f c t)",    "(f t r 10)", "(f t r 20)", "(f t r 30)", "(f t r 40)",
00901 "(f t r 50)", "(f r t)"   , "(f r t 30)", "(f r t 20)", "(f r t 10)",
00902 "(f g r t)" , "(f r 0)"   , "(f g r b)" , "(f r b 10)", "(f r b 20)",
00903 "(f r b 30)", "(f r b)"   , "(f b r 50)", "(f b r 40)", "(f b r 30)",
00904 "(f b r 20)", "(f b r 10)", "(f c b)"   , "(f b 0)"   , "(f b l 10)",
00905 "(f b l 20)", "(f b l 30)", "(f b l 40)", "(f b l 50)", "(f l b)",
00906 "(f l b 30)", "(f l b 20)", "(f l b 10)", "(f g l b)" , "(f l 0)",
00907 "(f g l t)" , "(f l t 10)", "(f l t 20)", "(f l t 30)", "(f p l t)",
00908 "(f p l c)", "(f p l b)",   "(f p r t)",  "(f p r c)",  "(f p r b)", "(f c)" } ;
00909 
00917 char* SoccerTypes::getObjectStr( char* strBuf, ObjectT o, const char *strTeamName )
00918 {
00919   if( o >= OBJECT_BALL && o <=   OBJECT_FLAG_C )
00920     sprintf( strBuf, ObjectNames[(int)o] );
00921   else if( isKnownPlayer( o ) )
00922     sprintf( strBuf, "(p %s %d)", strTeamName, getIndex( o ) + 1);
00923   else if( o == OBJECT_OPPONENT_UNKNOWN || o == OBJECT_TEAMMATE_UNKNOWN )
00924     sprintf( strBuf, "(p %s)", strTeamName );
00925   else if( o == OBJECT_PLAYER_UNKNOWN )
00926     sprintf( strBuf, "(p)" );
00927   else if( o == OBJECT_UNKNOWN )
00928     sprintf( strBuf, "(unknown)" );
00929   else
00930     sprintf( strBuf, "illegal: %d", (int)o );
00931   return strBuf;
00932 }
00933 
00943 ObjectT SoccerTypes::getObjectFromStr( char** str, bool *isGoalie,
00944                                        const char* strMyTeamName )
00945 {
00946   ObjectT o = OBJECT_ILLEGAL;
00947   char* ptrStr = *str;
00948   *isGoalie = false;
00949 
00950   switch( ptrStr[1] )
00951   {
00952     case 'b':                       // (ball)
00953     case 'B':                       // (B) in case of ball very close
00954        o = OBJECT_BALL; break;
00955     case 'G':
00956        o = OBJECT_GOAL_UNKNOWN;      // (G) in case of goal very close, ignored
00957       break;                        // (g l) or (g r) goal left or goal right
00958     case 'g': o = (ptrStr[3] == 'l') ? OBJECT_GOAL_L : OBJECT_GOAL_R; break;
00959     case 'l':                       // (l l), (l r), (l b) or (l t)
00960       switch( ptrStr[3] )
00961       {
00962         case 'l': o = OBJECT_LINE_L;  break;
00963         case 'r': o = OBJECT_LINE_R;  break;
00964         case 'b': o = OBJECT_LINE_B;  break;
00965         case 't': o = OBJECT_LINE_T;  break;
00966         default:  o = OBJECT_ILLEGAL; break;
00967       }
00968       break;
00969     case 'F':                       // (F) unkown flag very close.. ignored
00970       o = OBJECT_UNKNOWN; break;
00971     case 'f':                       // (f ...),  many options...
00972       switch( ptrStr[3] )
00973       {
00974         case 'l':                   // (f l ... lines on left part of field
00975           if( ptrStr[6] == ')' )    // only one character at index '5'
00976           {
00977             switch( ptrStr[5] )
00978             {
00979               case '0': o = OBJECT_FLAG_L_0; break; // (f l 0)
00980               case 't': o = OBJECT_FLAG_L_T; break; // (f l t)
00981               case 'b': o = OBJECT_FLAG_L_B; break; // (f l b)
00982               default:  o = OBJECT_ILLEGAL;  break;
00983             }
00984           }
00985           else                      // more than one character from index '5'
00986           {
00987             switch( ptrStr[7] )
00988             {
00989               case '1':             // (f l t 10) or (f l b 10)
00990                 o = (ptrStr[5]=='t')? OBJECT_FLAG_L_T_10 :OBJECT_FLAG_L_B_10;
00991                 break;
00992               case '2':             // (f l t 20) or (f l b 20)
00993                 o = (ptrStr[5]=='t')? OBJECT_FLAG_L_T_20 :OBJECT_FLAG_L_B_20;
00994                 break;
00995               case '3':             // (f l t 30) or (f l b 30)
00996                 o = (ptrStr[5]=='t')? OBJECT_FLAG_L_T_30 :OBJECT_FLAG_L_B_30;
00997                 break;
00998               default:
00999                 o = OBJECT_ILLEGAL;
01000                 break;
01001             }
01002           }
01003           break;
01004         case 'r':                   // (f r ... lines on right side of field
01005           if( ptrStr[6] == ')' )    // only one character at index '5'
01006           {
01007             switch( ptrStr[5] )
01008             {
01009               case '0': o = OBJECT_FLAG_R_0; break; // (f l 0)
01010               case 't': o = OBJECT_FLAG_R_T; break; // (f l t)
01011               case 'b': o = OBJECT_FLAG_R_B; break; // (f l b)
01012             }
01013           }
01014           else
01015           {
01016             switch( ptrStr[7] )     // more than one character from index '5'
01017             {
01018               case '1':
01019                 o = (ptrStr[5]=='t')? OBJECT_FLAG_R_T_10 :OBJECT_FLAG_R_B_10;
01020                 break;
01021               case '2':             // (f r t 10) or (f r b 10)
01022                 o = (ptrStr[5]=='t')? OBJECT_FLAG_R_T_20 :OBJECT_FLAG_R_B_20;
01023                 break;              // (f r t 20) or (f r b 20)
01024               case '3':
01025                 o = (ptrStr[5]=='t')? OBJECT_FLAG_R_T_30 :OBJECT_FLAG_R_B_30;
01026                 break;              // (f r t 30) or (f r b 30)
01027               default:
01028                 o = OBJECT_ILLEGAL;
01029                 break;
01030             }
01031           }
01032           break;
01033         case 't':                   // lines on top part of field
01034           if( ptrStr[5] == '0' )
01035             o = OBJECT_FLAG_T_0;    // (f t 0) center flag
01036           else
01037           {
01038             switch( ptrStr[7] )     // rest of the top flags
01039             {
01040               case '1':             // (f t l 10) or (f t r 10)
01041                 o = (ptrStr[5]=='l') ? OBJECT_FLAG_T_L_10 : OBJECT_FLAG_T_R_10;
01042                 break;
01043               case '2':             // (f t l 20) or (f t r 20)
01044                 o = (ptrStr[5]=='l') ? OBJECT_FLAG_T_L_20 : OBJECT_FLAG_T_R_20;
01045                 break;
01046               case '3':             // (f t l 30) or (f t r 30)
01047                 o = (ptrStr[5]=='l') ? OBJECT_FLAG_T_L_30 : OBJECT_FLAG_T_R_30;
01048                 break;
01049               case '4':             // (f t l 40) or (f t r 40)
01050                 o = (ptrStr[5]=='l') ? OBJECT_FLAG_T_L_40 : OBJECT_FLAG_T_R_40;
01051                 break;
01052               case '5':             // (f t l 50) or (f t r 50)
01053                 o = (ptrStr[5]=='l') ? OBJECT_FLAG_T_L_50 : OBJECT_FLAG_T_R_50;
01054                 break;
01055             }
01056           }
01057           break;
01058         case 'b':                   // lines on bottom part of field
01059           if( ptrStr[5] == '0')
01060             o = OBJECT_FLAG_B_0;    // (f b 0) center flag
01061           else
01062           {
01063             switch( ptrStr[7] )     // rest of the bottom flags
01064             {
01065               case '1':             // (f b l 10) or (f b r 10)
01066                 o = (ptrStr[5]=='l') ? OBJECT_FLAG_B_L_10 : OBJECT_FLAG_B_R_10;
01067                 break;
01068               case '2':             // (f b l 20) or (f b r 20)
01069                 o = (ptrStr[5]=='l') ? OBJECT_FLAG_B_L_20 : OBJECT_FLAG_B_R_20;
01070                 break;
01071               case '3':             // (f b l 30) or (f b r 30)
01072                 o = (ptrStr[5]=='l') ? OBJECT_FLAG_B_L_30 : OBJECT_FLAG_B_R_30;
01073                 break;
01074               case '4':             // (f b l 40) or (f b r 40)
01075                 o = (ptrStr[5]=='l') ? OBJECT_FLAG_B_L_40 : OBJECT_FLAG_B_R_40;
01076                 break;
01077               case '5':             // (f b l 50) or (f b r 50)
01078                 o = (ptrStr[5]=='l') ? OBJECT_FLAG_B_L_50 : OBJECT_FLAG_B_R_50;
01079                 break;
01080             }
01081           }
01082           break;
01083         case 'c':                   // center flags
01084           if( ptrStr[4] == ')' )
01085             o = OBJECT_FLAG_C;      // (f c) flag in midpoint field
01086           else                      // (f c t) or (f c b)
01087             o = (ptrStr[5] == 't') ? OBJECT_FLAG_C_T : OBJECT_FLAG_C_B;
01088           break;
01089         case 'g':                   // goal flags
01090           if( ptrStr[5] == 'l' )    // (g l t) or (g l b)
01091             o = (ptrStr[7] == 't') ? OBJECT_FLAG_G_L_T : OBJECT_FLAG_G_L_B;
01092           else                      // (g r t) or (g r b)
01093             o = (ptrStr[7] == 't') ? OBJECT_FLAG_G_R_T : OBJECT_FLAG_G_R_B;
01094           break;
01095         case 'p':                   // flags at sides penalty area
01096           switch( ptrStr[7] )
01097           {
01098             case 't':               // (p l t) or (p r t) top penalty area
01099               o = (ptrStr[5] == 'l') ? OBJECT_FLAG_P_L_T : OBJECT_FLAG_P_R_T;
01100               break;
01101             case 'c':               // (p l c) or (p r c) center penalty area
01102               o = (ptrStr[5] == 'l') ? OBJECT_FLAG_P_L_C : OBJECT_FLAG_P_R_C;
01103               break;
01104             case 'b':               // (p l b) or (p r b) bottom penalty area
01105               o = (ptrStr[5] == 'l') ? OBJECT_FLAG_P_L_B : OBJECT_FLAG_P_R_B;
01106               break;
01107             default:
01108               o = OBJECT_ILLEGAL;
01109               break;
01110           }
01111           break;
01112         default:
01113           o = OBJECT_ILLEGAL;
01114       }
01115       break; // end flags (finally)
01116   case 'p': // (p team nr) or (p team) or (p) player teammate or opponent
01117   case 'P': // or (P)
01118     ptrStr += 2;
01119 
01120 
01121     if( Parse::gotoFirstSpaceOrClosingBracket(&ptrStr) == ')' )
01122       o = OBJECT_PLAYER_UNKNOWN; // if (p) or (P) player is unknown.
01123     // check also with quotes since later versions use string around "teamname"
01124     else if( strncmp( ptrStr+1, strMyTeamName, strlen( strMyTeamName ) ) == 0 ||
01125              strncmp( ptrStr+2, strMyTeamName, strlen( strMyTeamName ) ) == 0 )
01126     {
01127       ptrStr++;
01128       if( Parse::gotoFirstSpaceOrClosingBracket(&ptrStr) == ' ' )
01129       {                                               // also team number
01130         switch( Parse::parseFirstInt( &ptrStr ) )     // get team number
01131         {
01132           case 1:  o = OBJECT_TEAMMATE_1;  break;     // and find team member
01133           case 2:  o = OBJECT_TEAMMATE_2;  break;
01134           case 3:  o = OBJECT_TEAMMATE_3;  break;
01135           case 4:  o = OBJECT_TEAMMATE_4;  break;
01136           case 5:  o = OBJECT_TEAMMATE_5;  break;
01137           case 6:  o = OBJECT_TEAMMATE_6;  break;
01138           case 7:  o = OBJECT_TEAMMATE_7;  break;
01139           case 8:  o = OBJECT_TEAMMATE_8;  break;
01140           case 9:  o = OBJECT_TEAMMATE_9;  break;
01141           case 10: o = OBJECT_TEAMMATE_10; break;
01142           case 11: o = OBJECT_TEAMMATE_11; break;
01143           default: o = OBJECT_ILLEGAL;
01144         }
01145         if( ptrStr[0] != ')' && ptrStr[1] == 'g' ) // goalie
01146           *isGoalie = true;
01147       }
01148       else
01149         o = OBJECT_TEAMMATE_UNKNOWN;                  // (p team) but no nr
01150     }
01151     else                                              // not a teammate
01152     {
01153       ptrStr++;
01154       if( Parse::gotoFirstSpaceOrClosingBracket( &ptrStr ) == ' ' )
01155       {                                               // also team number
01156         switch( Parse::parseFirstInt( &ptrStr ) )     // get team numer
01157         {
01158           case 1:  o = OBJECT_OPPONENT_1;  break;     // and return opponent
01159           case 2:  o = OBJECT_OPPONENT_2;  break;
01160           case 3:  o = OBJECT_OPPONENT_3;  break;
01161           case 4:  o = OBJECT_OPPONENT_4;  break;
01162           case 5:  o = OBJECT_OPPONENT_5;  break;
01163           case 6:  o = OBJECT_OPPONENT_6;  break;
01164           case 7:  o = OBJECT_OPPONENT_7;  break;
01165           case 8:  o = OBJECT_OPPONENT_8;  break;
01166           case 9:  o = OBJECT_OPPONENT_9;  break;
01167           case 10: o = OBJECT_OPPONENT_10; break;
01168           case 11: o = OBJECT_OPPONENT_11; break;
01169           default: o = OBJECT_ILLEGAL;
01170         }
01171         if( ptrStr[0] != ')' && ptrStr[1] == 'g' ) // goalie
01172           *isGoalie = true;
01173       }
01174       else
01175         o = OBJECT_OPPONENT_UNKNOWN;                  // number not known
01176 
01177     }
01178     break;
01179   default:
01180     cerr << "(SoccerTypes::getObjectFromStr) Unknown msg: " <<  ptrStr << endl;
01181     char buf[1000];
01182     printf("%d, %s\n", o, SoccerTypes::getObjectStr(buf,o,"1") );
01183     break;
01184   }
01185   // go to the end of the object
01186   Parse::gotoFirstOccurenceOf( ')', &ptrStr );
01187   *str=ptrStr;
01188   return o;
01189 }
01190 
01197 int SoccerTypes::getIndex( ObjectT o )
01198 {
01199   if( o >= OBJECT_OPPONENT_1 && o <= OBJECT_OPPONENT_11 )
01200     return o - OBJECT_OPPONENT_1;
01201   else if( o >= OBJECT_TEAMMATE_1 && o <= OBJECT_TEAMMATE_11 )
01202     return o - OBJECT_TEAMMATE_1;
01203   else if( o >= OBJECT_GOAL_L && o <= OBJECT_GOAL_R )
01204     return o - OBJECT_GOAL_L;
01205   else if( o >= OBJECT_FLAG_L_T && o <= OBJECT_FLAG_C )
01206     return o - OBJECT_FLAG_L_T + 2; // 2 added for the two goals
01207   else if( o >= OBJECT_LINE_L && o <= OBJECT_LINE_T )
01208     return o - OBJECT_LINE_L;
01209   else
01210     return -1;
01211 }
01212 
01217 ObjectT SoccerTypes::getTeammateObjectFromIndex( int iIndex )
01218 {
01219   return (ObjectT) ( OBJECT_TEAMMATE_1 + iIndex );
01220 }
01221 
01226 ObjectT SoccerTypes::getOpponentObjectFromIndex( int iIndex )
01227 {
01228   return (ObjectT) ( OBJECT_OPPONENT_1 + iIndex );
01229 }
01230 
01237 bool SoccerTypes::isInSet( ObjectT o, ObjectSetT o_g )
01238 {
01239   switch( o_g )
01240   {
01241     case OBJECT_SET_TEAMMATES: return isTeammate( o ) && isKnownPlayer( o );
01242     case OBJECT_SET_OPPONENTS: return isOpponent( o ) && isKnownPlayer( o );
01243     case OBJECT_SET_PLAYERS:   return isPlayer  ( o ) && isKnownPlayer( o );
01244     case OBJECT_SET_FLAGS:     return isFlag    ( o );
01245     case OBJECT_SET_LINES:     return isLine    ( o );
01246     case OBJECT_SET_ILLEGAL:
01247     default:                   return false;
01248   }
01249   return false;
01250 }
01254 bool SoccerTypes::isFlag( ObjectT o )
01255 {
01256   return ( o >= OBJECT_FLAG_L_T && o <= OBJECT_FLAG_C ) ||
01257          ( o >= OBJECT_GOAL_L   && o <= OBJECT_GOAL_R        );
01258 }
01259 
01263 bool SoccerTypes::isLine( ObjectT o )
01264 {
01265   return o >= OBJECT_LINE_L && o <= OBJECT_LINE_T;
01266 }
01267 
01271 bool SoccerTypes::isGoal( ObjectT o )
01272 {
01273   return o == OBJECT_GOAL_L || o == OBJECT_GOAL_R;
01274 }
01275 
01279 bool SoccerTypes::isTeammate( ObjectT o )
01280 {
01281   return o >= OBJECT_TEAMMATE_1 && o <= OBJECT_TEAMMATE_UNKNOWN;
01282 }
01283 
01287 bool SoccerTypes::isOpponent( ObjectT o )
01288 {
01289   return o >= OBJECT_OPPONENT_1 && o <= OBJECT_OPPONENT_UNKNOWN;
01290 }
01291 
01296 bool SoccerTypes::isPlayer( ObjectT o )
01297 {
01298   return isKnownPlayer( o )           || o == OBJECT_TEAMMATE_UNKNOWN ||
01299          o == OBJECT_OPPONENT_UNKNOWN || o == OBJECT_PLAYER_UNKNOWN;
01300 }
01301 
01306 bool SoccerTypes::isKnownPlayer( ObjectT o )
01307 {
01308   return (o >= OBJECT_OPPONENT_1 && o <= OBJECT_OPPONENT_11) ||
01309          (o >= OBJECT_TEAMMATE_1 && o <= OBJECT_TEAMMATE_11);
01310 }
01311 
01316 bool SoccerTypes::isGoalie( ObjectT o )
01317 {
01318   return o == OBJECT_TEAMMATE_1 || o == OBJECT_OPPONENT_1;
01319 }
01320 
01324 bool SoccerTypes::isBall( ObjectT o )
01325 {
01326   return o == OBJECT_BALL;
01327 }
01328 
01332 ObjectT SoccerTypes::getOwnGoal( SideT s )
01333 {
01334   if( SIDE_LEFT == s )
01335     return OBJECT_GOAL_L;
01336   else if( SIDE_RIGHT == s )
01337     return OBJECT_GOAL_R;
01338 
01339   cerr << "(SoccerTypes::isOwnGoal) Wrong side argument" << endl;
01340   return OBJECT_ILLEGAL;
01341 }
01342 
01346 ObjectT SoccerTypes::getGoalOpponent( SideT s )
01347 {
01348   if( SIDE_LEFT == s )
01349     return OBJECT_GOAL_R;
01350   else if( SIDE_RIGHT == s )
01351     return OBJECT_GOAL_L;
01352 
01353   cerr << "(SoccerTypes::isGoalOpponent) Wrong side argument" << endl;
01354   return OBJECT_ILLEGAL;
01355 }
01356 
01366 VecPosition SoccerTypes::getGlobalPositionFlag( ObjectT o, SideT s,
01367                                                              double dGoalWidth )
01368 {
01369   VecPosition pos;
01370   if( !(isFlag(o) || isGoal(o)) )
01371       return VecPosition(UnknownDoubleValue, UnknownDoubleValue);
01372   switch( o ) // for every object the global position is entered
01373   {
01374     case OBJECT_GOAL_L:
01375       pos.setVecPosition( -PITCH_LENGTH/2.0, 0.0 );                  break;
01376     case OBJECT_GOAL_R:
01377       pos.setVecPosition(  PITCH_LENGTH/2.0, 0.0 );                  break;
01378     case OBJECT_FLAG_L_T:
01379       pos.setVecPosition( -PITCH_LENGTH/2.0, -PITCH_WIDTH/2.0 );     break;
01380     case OBJECT_FLAG_T_L_50:
01381       pos.setVecPosition( -50.0, -PITCH_WIDTH/2.0 - PITCH_MARGIN );  break;
01382     case OBJECT_FLAG_T_L_40:
01383       pos.setVecPosition( -40.0, -PITCH_WIDTH/2.0 - PITCH_MARGIN );  break;
01384     case OBJECT_FLAG_T_L_30:
01385       pos.setVecPosition( -30.0, -PITCH_WIDTH/2.0 - PITCH_MARGIN );  break;
01386     case OBJECT_FLAG_T_L_20:
01387       pos.setVecPosition( -20.0, -PITCH_WIDTH/2.0 - PITCH_MARGIN );  break;
01388     case OBJECT_FLAG_T_L_10:
01389       pos.setVecPosition( -10.0, -PITCH_WIDTH/2.0 - PITCH_MARGIN );  break;
01390     case OBJECT_FLAG_T_0:
01391       pos.setVecPosition(   0.0, -PITCH_WIDTH/2.0 - PITCH_MARGIN );  break;
01392     case OBJECT_FLAG_C_T:
01393       pos.setVecPosition(   0.0, -PITCH_WIDTH/2.0);                  break;
01394     case OBJECT_FLAG_T_R_10:
01395       pos.setVecPosition(  10.0,  -PITCH_WIDTH/2.0 - PITCH_MARGIN);  break;
01396     case OBJECT_FLAG_T_R_20:
01397       pos.setVecPosition(  20.0,  -PITCH_WIDTH/2.0 - PITCH_MARGIN);  break;
01398     case OBJECT_FLAG_T_R_30:
01399       pos.setVecPosition(  30.0,  -PITCH_WIDTH/2.0 - PITCH_MARGIN);  break;
01400     case OBJECT_FLAG_T_R_40:
01401       pos.setVecPosition(  40.0,  -PITCH_WIDTH/2.0 - PITCH_MARGIN);  break;
01402     case OBJECT_FLAG_T_R_50:
01403       pos.setVecPosition(  50.0,  -PITCH_WIDTH/2.0 - PITCH_MARGIN);  break;
01404     case OBJECT_FLAG_R_T:
01405       pos.setVecPosition( PITCH_LENGTH/2.0,  -PITCH_WIDTH/2.0 );     break;
01406     case OBJECT_FLAG_R_T_30:
01407       pos.setVecPosition( PITCH_LENGTH/2.0 + PITCH_MARGIN,  -30.0 ); break;
01408     case OBJECT_FLAG_R_T_20:
01409       pos.setVecPosition( PITCH_LENGTH/2.0 + PITCH_MARGIN,  -20.0 ); break;
01410     case OBJECT_FLAG_R_T_10:
01411       pos.setVecPosition( PITCH_LENGTH/2.0 + PITCH_MARGIN,  -10.0 ); break;
01412     case OBJECT_FLAG_G_R_T:
01413       pos.setVecPosition( PITCH_LENGTH/2.0,  -dGoalWidth/2.0 );      break;
01414     case OBJECT_FLAG_R_0:
01415       pos.setVecPosition( PITCH_LENGTH/2.0 + PITCH_MARGIN,  0.0 );   break;
01416     case OBJECT_FLAG_G_R_B:
01417       pos.setVecPosition( PITCH_LENGTH/2.0,  dGoalWidth/2.0 );       break;
01418     case OBJECT_FLAG_R_B_10:
01419       pos.setVecPosition( PITCH_LENGTH/2.0 + PITCH_MARGIN,  10.0 );  break;
01420     case OBJECT_FLAG_R_B_20:
01421       pos.setVecPosition( PITCH_LENGTH/2.0 + PITCH_MARGIN,  20.0 );  break;
01422     case OBJECT_FLAG_R_B_30:
01423       pos.setVecPosition( PITCH_LENGTH/2.0 + PITCH_MARGIN,  30.0 );  break;
01424     case OBJECT_FLAG_R_B:
01425       pos.setVecPosition( PITCH_LENGTH/2.0,  PITCH_WIDTH/2.0 );      break;
01426     case OBJECT_FLAG_B_R_50:
01427       pos.setVecPosition(  50.0, PITCH_WIDTH/2.0 + PITCH_MARGIN );   break;
01428     case OBJECT_FLAG_B_R_40:
01429       pos.setVecPosition(  40.0, PITCH_WIDTH/2.0 + PITCH_MARGIN );   break;
01430     case OBJECT_FLAG_B_R_30:
01431       pos.setVecPosition(  30.0, PITCH_WIDTH/2.0 + PITCH_MARGIN );   break;
01432     case OBJECT_FLAG_B_R_20:
01433       pos.setVecPosition(  20.0, PITCH_WIDTH/2.0 + PITCH_MARGIN );   break;
01434     case OBJECT_FLAG_B_R_10:
01435       pos.setVecPosition(  10.0, PITCH_WIDTH/2.0 + PITCH_MARGIN );   break;
01436     case OBJECT_FLAG_C_B:
01437       pos.setVecPosition(   0.0, PITCH_WIDTH/2.0 );                  break;
01438     case OBJECT_FLAG_B_0:
01439       pos.setVecPosition(   0.0, PITCH_WIDTH/2.0 + PITCH_MARGIN );   break;
01440     case OBJECT_FLAG_B_L_10:
01441       pos.setVecPosition( -10.0, PITCH_WIDTH/2.0 + PITCH_MARGIN );   break;
01442     case OBJECT_FLAG_B_L_20:
01443       pos.setVecPosition( -20.0, PITCH_WIDTH/2.0 + PITCH_MARGIN );   break;
01444     case OBJECT_FLAG_B_L_30:
01445       pos.setVecPosition( -30.0, PITCH_WIDTH/2.0 + PITCH_MARGIN );   break;
01446     case OBJECT_FLAG_B_L_40:
01447       pos.setVecPosition( -40.0, PITCH_WIDTH/2.0 + PITCH_MARGIN );   break;
01448     case OBJECT_FLAG_B_L_50:
01449       pos.setVecPosition( -50.0, PITCH_WIDTH/2.0 + PITCH_MARGIN );   break;
01450     case OBJECT_FLAG_L_B:
01451       pos.setVecPosition( -PITCH_LENGTH/2.0,  PITCH_WIDTH/2.0 );     break;
01452     case OBJECT_FLAG_L_B_30:
01453       pos.setVecPosition( -PITCH_LENGTH/2.0 - PITCH_MARGIN,  30.0 ); break;
01454     case OBJECT_FLAG_L_B_20:
01455       pos.setVecPosition( -PITCH_LENGTH/2.0 - PITCH_MARGIN,  20.0 ); break;
01456     case OBJECT_FLAG_L_B_10:
01457       pos.setVecPosition( -PITCH_LENGTH/2.0 - PITCH_MARGIN,  10.0 ); break;
01458     case OBJECT_FLAG_G_L_B:
01459       pos.setVecPosition( -PITCH_LENGTH/2.0,  dGoalWidth/2.0 );      break;
01460     case OBJECT_FLAG_L_0:
01461       pos.setVecPosition( -PITCH_LENGTH/2.0 - PITCH_MARGIN,  0.0 );  break;
01462     case OBJECT_FLAG_G_L_T:
01463       pos.setVecPosition( -PITCH_LENGTH/2.0,  -dGoalWidth/2.0 );     break;
01464     case OBJECT_FLAG_L_T_10:
01465       pos.setVecPosition( -PITCH_LENGTH/2.0 - PITCH_MARGIN, -10.0 ); break;
01466     case OBJECT_FLAG_L_T_20:
01467       pos.setVecPosition( -PITCH_LENGTH/2.0 - PITCH_MARGIN, -20.0 ); break;
01468     case OBJECT_FLAG_L_T_30:
01469       pos.setVecPosition( -PITCH_LENGTH/2.0 - PITCH_MARGIN, -30.0 ); break;
01470     case OBJECT_FLAG_P_L_T:
01471       pos.setVecPosition( -PITCH_LENGTH/2.0 + PENALTY_AREA_LENGTH,
01472                                          - PENALTY_AREA_WIDTH/2.0 ); break;
01473     case OBJECT_FLAG_P_L_C:
01474       pos.setVecPosition( -PITCH_LENGTH/2.0 + PENALTY_AREA_LENGTH, 0.0 ); break;
01475     case OBJECT_FLAG_P_L_B:
01476       pos.setVecPosition( -PITCH_LENGTH/2.0 + PENALTY_AREA_LENGTH,
01477                                            PENALTY_AREA_WIDTH/2.0 ); break;
01478     case OBJECT_FLAG_P_R_T:
01479       pos.setVecPosition(  PITCH_LENGTH/2.0 - PENALTY_AREA_LENGTH,
01480                                           -PENALTY_AREA_WIDTH/2.0 ); break;
01481     case OBJECT_FLAG_P_R_C:
01482       pos.setVecPosition(  PITCH_LENGTH/2.0 - PENALTY_AREA_LENGTH, 0.0 ); break;
01483     case OBJECT_FLAG_P_R_B:
01484       pos.setVecPosition(  PITCH_LENGTH/2.0 - PENALTY_AREA_LENGTH,
01485                                            PENALTY_AREA_WIDTH/2.0 ); break;
01486     case OBJECT_FLAG_C:
01487       pos.setVecPosition(  0.0 , 0.0 );                              break;
01488     default:
01489       cerr << "(SoccerTypes::getGlobalPositionObject) wrong objecttype! " <<
01490         (int)o << endl ;
01491   }
01492 
01493   if( s == SIDE_RIGHT ) // change side for team on the right side.
01494       pos.setVecPosition( -pos.getX(), -pos.getY() );
01495   return pos;
01496 }
01497 
01506 AngDeg SoccerTypes::getGlobalAngleLine( ObjectT o , SideT s )
01507 {
01508   AngDeg angle = UnknownAngleValue;
01509   switch( o )
01510   {
01511     case OBJECT_LINE_L: angle = 180.0; break;
01512     case OBJECT_LINE_R: angle =   0.0; break;
01513     case OBJECT_LINE_T: angle = -90.0; break;
01514     case OBJECT_LINE_B: angle =  90.0; break;
01515   default:
01516     cerr << "(SoccerTypes::getGlobalAngleLine) wrong objecttype! " <<
01517       (int)o << endl;
01518     return UnknownAngleValue;
01519   }
01520 
01521   if( s == SIDE_RIGHT )
01522     angle += 180;
01523 
01524   return VecPosition::normalizeAngle( angle );
01525 }
01526 
01531 char* SoccerTypes::getPlayModeStr( PlayModeT pm )
01532 {
01533   switch( pm )
01534   {
01535     case PM_BEFORE_KICK_OFF:       return "before_kick_off";
01536     case PM_KICK_OFF_LEFT:         return "kick_off_l";
01537     case PM_KICK_OFF_RIGHT:        return "kick_off_r";
01538     case PM_KICK_IN_LEFT:          return "kick_in_l";
01539     case PM_KICK_IN_RIGHT:         return "kick_in_r";
01540     case PM_CORNER_KICK_LEFT:      return "corner_kick_l";
01541     case PM_CORNER_KICK_RIGHT:     return "corner_kick_r";
01542     case PM_GOAL_KICK_LEFT:        return "goal_kick_l";
01543     case PM_GOAL_KICK_RIGHT:       return "goal_kick_r";
01544     case PM_GOAL_LEFT:             return "goal_r";
01545     case PM_GOAL_RIGHT:            return "goal_l";
01546     case PM_FREE_KICK_FAULT_LEFT:  return "free_kick_fault_l";    
01547     case PM_FREE_KICK_FAULT_RIGHT: return "free_kick_fault_r";    
01548     case PM_FREE_KICK_LEFT:        return "free_kick_l";
01549     case PM_FREE_KICK_RIGHT:       return "free_kick_r";
01550     case PM_BACK_PASS_LEFT:        return "back_pass_l";
01551     case PM_BACK_PASS_RIGHT:       return "back_pass_r";
01552     case PM_OFFSIDE_LEFT:          return "offside_l";
01553     case PM_OFFSIDE_RIGHT:         return "offside_l";    
01554     case PM_PLAY_ON:               return "play_on";
01555     case PM_FROZEN:                return "play_off";
01556     case PM_QUIT:                  return "quit";
01557     case PM_ILLEGAL:
01558     default:                       return NULL;
01559    }
01560 }
01561 
01565 PlayModeT SoccerTypes::getPlayModeFromStr( char* str )
01566 {
01567   // all play modes are sent as referee message, so get referee message
01568   // and look up the associated play mode
01569   return getPlayModeFromRefereeMessage( getRefereeMessageFromStr( str ) );
01570 }
01571 
01575 PlayModeT SoccerTypes::getPlayModeFromRefereeMessage( RefereeMessageT rm )
01576 {
01577   switch( rm )
01578   {
01579     case REFC_BEFORE_KICK_OFF:        return PM_BEFORE_KICK_OFF;
01580     case REFC_KICK_OFF_LEFT:          return PM_KICK_OFF_LEFT;
01581     case REFC_KICK_OFF_RIGHT:         return PM_KICK_OFF_RIGHT;
01582     case REFC_KICK_IN_LEFT:           return PM_KICK_IN_LEFT;
01583     case REFC_KICK_IN_RIGHT:          return PM_KICK_IN_RIGHT;
01584     case REFC_CORNER_KICK_LEFT:       return PM_CORNER_KICK_LEFT;
01585     case REFC_CORNER_KICK_RIGHT:      return PM_CORNER_KICK_RIGHT;
01586     case REFC_GOAL_KICK_LEFT:         return PM_GOAL_KICK_LEFT;
01587     case REFC_GOAL_KICK_RIGHT:        return PM_GOAL_KICK_RIGHT;
01588     case REFC_FREE_KICK_LEFT:         return PM_FREE_KICK_LEFT;
01589     case REFC_FREE_KICK_RIGHT:        return PM_FREE_KICK_RIGHT;
01590     case REFC_FREE_KICK_FAULT_LEFT:   return PM_FREE_KICK_FAULT_LEFT;
01591     case REFC_FREE_KICK_FAULT_RIGHT:  return PM_FREE_KICK_FAULT_RIGHT;
01592     case REFC_BACK_PASS_LEFT:         return PM_BACK_PASS_LEFT;
01593     case REFC_BACK_PASS_RIGHT:        return PM_BACK_PASS_RIGHT;
01594     case REFC_FOUL_LEFT:              return PM_FREE_KICK_RIGHT;
01595     case REFC_FOUL_RIGHT:             return PM_FREE_KICK_LEFT;
01596     case REFC_OFFSIDE_LEFT:           return PM_OFFSIDE_LEFT;
01597     case REFC_OFFSIDE_RIGHT:          return PM_OFFSIDE_RIGHT;
01598     case REFC_GOAL_LEFT:              return PM_GOAL_LEFT;
01599     case REFC_GOAL_RIGHT:             return PM_GOAL_RIGHT;
01600     case REFC_PLAY_ON:                return PM_PLAY_ON;
01601     case REFC_FROZEN:                 return PM_FROZEN;
01602     case REFC_TIME_OVER:              return PM_TIME_OVER;
01603     case REFC_QUIT:                   return PM_QUIT;
01604     default:                          return PM_ILLEGAL;
01605   }
01606 }
01607 
01612 char* SoccerTypes::getRefereeMessageStr( RefereeMessageT rm )
01613 {
01614   switch( rm )
01615   {
01616     case REFC_BEFORE_KICK_OFF:        return "before_kick_off";
01617     case REFC_KICK_OFF_LEFT:          return "kick_off_l";
01618     case REFC_KICK_OFF_RIGHT:         return "kick_off_r";
01619     case REFC_KICK_IN_LEFT:           return "kick_in_l";
01620     case REFC_KICK_IN_RIGHT:          return "kick_in_r";
01621     case REFC_CORNER_KICK_LEFT:       return "corner_kick_l";
01622     case REFC_CORNER_KICK_RIGHT:      return "corner_kick_r";
01623     case REFC_GOAL_KICK_LEFT:         return "goal_kick_l";
01624     case REFC_GOAL_KICK_RIGHT:        return "goal_kick_r";
01625     case REFC_FREE_KICK_LEFT:         return "free_kick_l";
01626     case REFC_FREE_KICK_RIGHT:        return "free_kick_r";
01627     case REFC_FREE_KICK_FAULT_LEFT:   return "free_kick_fault_l";
01628     case REFC_FREE_KICK_FAULT_RIGHT:  return "free_kick_fault_r";
01629     case REFC_BACK_PASS_LEFT:         return "back_pass_l";
01630     case REFC_BACK_PASS_RIGHT:        return "back_pass_r";
01631     case REFC_PLAY_ON:                return "play_on";
01632     case REFC_FROZEN:                 return "play_off";
01633     case REFC_QUIT:                   return "quit";
01634     case REFC_OFFSIDE_LEFT:           return "offside_l";
01635     case REFC_OFFSIDE_RIGHT:          return "offside_r";
01636     case REFC_HALF_TIME:              return "half_time";
01637     case REFC_TIME_UP:                return "time_up";
01638     case REFC_TIME_OVER:              return "time_over";
01639     case REFC_TIME_UP_WITHOUT_A_TEAM: return "time_up_without_a_team";
01640     case REFC_TIME_EXTENDED:          return "time_extended";
01641     case REFC_FOUL_LEFT:              return "foul_l";
01642     case REFC_FOUL_RIGHT:             return "foul_r";
01643     case REFC_GOAL_LEFT:              return "goal_l";
01644     case REFC_GOAL_RIGHT:             return "goal_r";
01645     case REFC_DROP_BALL:              return "drop_ball";
01646     case REFC_GOALIE_CATCH_BALL_LEFT: return "goalie_catch_ball_l";
01647     case REFC_GOALIE_CATCH_BALL_RIGHT:return "goalie_catch_ball_r";
01648     case REFC_ILLEGAL:
01649     default:                          return NULL;
01650   }
01651 }
01652 
01653 
01657 RefereeMessageT SoccerTypes::getRefereeMessageFromStr( char* str )
01658 {
01659   switch( str[0] )
01660   {
01661     case 'b':                   // before_kick_off, back_pass_[lr]
01662       if( str[1] == 'e' )
01663         return REFC_BEFORE_KICK_OFF;
01664       else 
01665         return (str[10] == 'l') ? REFC_BACK_PASS_LEFT : REFC_BACK_PASS_RIGHT;
01666     case 'c':                   // corner_kick_l or corner_kick_r
01667       return (str[12] == 'l') ? REFC_CORNER_KICK_LEFT : REFC_CORNER_KICK_RIGHT;
01668     case 'd':                   // drop_ball
01669       return REFC_DROP_BALL;
01670     case 'g':
01671       switch( str[5] )
01672       {
01673         case 'k':              // goal_kick_l, goal_kick_r
01674           return (str[10] == 'l') ? REFC_GOAL_KICK_LEFT : REFC_GOAL_KICK_RIGHT;
01675         case 'e':              // goalie_catch_ball_l, goalie_catch_ball_r
01676           return (str[18] == 'l') ? REFC_GOALIE_CATCH_BALL_LEFT
01677                                   : REFC_GOALIE_CATCH_BALL_RIGHT;
01678         case 'l':              // goal_l
01679           return REFC_GOAL_LEFT;
01680         case 'r':              // goal_r
01681           return REFC_GOAL_RIGHT;
01682       }
01683     case 'h':                  // half_time
01684       return REFC_HALF_TIME;
01685     case 'f':
01686       if( str[5] == 'k' )      // free_kick_[lr], free_kick_fault_[lr]
01687       {
01688         if( str[10] == 'f' ) 
01689           return ( str[16] == 'l' ) 
01690                     ? REFC_FREE_KICK_FAULT_LEFT 
01691                     : REFC_FREE_KICK_FAULT_RIGHT;
01692         else 
01693           return (str[10] == 'l') ? REFC_FREE_KICK_LEFT : REFC_FREE_KICK_RIGHT;
01694       }
01695       else if( str[5] == 'l' ) // foul_l
01696         return REFC_FOUL_LEFT;
01697       else if( str[5] == 'r' ) // foul_r
01698         return REFC_FOUL_RIGHT;
01699     case 'k':                  // kick_in_l, kick_in_r, kick_off_l, kick_off_r
01700       if( str[5] == 'i' )
01701         return (str[8] == 'l' )   ? REFC_KICK_IN_LEFT   : REFC_KICK_IN_RIGHT;
01702       else if( str[5] == 'o' )
01703         return (str[9] == 'l' )   ? REFC_KICK_OFF_LEFT  : REFC_KICK_OFF_RIGHT;
01704     case 'o':
01705       return ( str[8] == 'l' )    ? REFC_OFFSIDE_LEFT   : REFC_OFFSIDE_RIGHT;
01706     case 'p':                  // play_on
01707       return REFC_PLAY_ON;
01708     case 't':
01709       if( str[5] == 'o' )      // time_over
01710         return REFC_TIME_OVER;
01711       else if( str[5] == 'e' ) // time_extended
01712         return REFC_TIME_EXTENDED;
01713       else if( str[5] == 'u' ) // time_up
01714         return REFC_TIME_UP;
01715       else if( str[8] == 'w' ) // time_up_without_a_team
01716         return REFC_TIME_UP_WITHOUT_A_TEAM;
01717     default:
01718       printf("(SoccerTypes::getRefereeMessageFromStr) ?? ref msg %s\n",str);
01719       return REFC_ILLEGAL;
01720   }
01721 }
01722 
01723 
01728 char* SoccerTypes::getViewAngleStr( ViewAngleT va )
01729 {
01730   switch( va )
01731   {
01732     case VA_NARROW:  return "narrow";
01733     case VA_NORMAL:  return "normal";
01734     case VA_WIDE:    return "wide";
01735     case VA_ILLEGAL:
01736     default:         return NULL;
01737   }
01738 }
01739 
01743 ViewAngleT SoccerTypes::getViewAngleFromStr( char* str )
01744 {
01745   switch( str[1] )
01746   {
01747     case 'a': return VA_NARROW;
01748     case 'o': return VA_NORMAL;
01749     case 'i': return VA_WIDE;
01750     default:  return VA_ILLEGAL;
01751   }
01752 }
01753 
01761 AngDeg SoccerTypes::getHalfViewAngleValue( ViewAngleT va )
01762 {
01763   switch( va )
01764   {
01765     case VA_NARROW:  return 22.5;
01766     case VA_NORMAL:  return 45.0;
01767     case VA_WIDE:    return 90.0;
01768     case VA_ILLEGAL:
01769     default:         return 0.0;
01770   }
01771 
01772 }
01773 
01778 char* SoccerTypes::getViewQualityStr( ViewQualityT vq )
01779 {
01780   switch( vq )
01781   {
01782     case VQ_HIGH:    return "high";
01783     case VQ_LOW:     return "low";
01784     case VQ_ILLEGAL:
01785     default:         return NULL;
01786   }
01787 }
01788 
01793 ViewQualityT SoccerTypes::getViewQualityFromStr( char* str )
01794 {
01795     if( str[0] == 'h' )      return VQ_HIGH;
01796     else if( str[0] == 'l' ) return VQ_LOW;
01797     else                     return VQ_ILLEGAL;
01798 }
01799 
01804 char* SoccerTypes::getCommandStr( CommandT com )
01805 {
01806   switch( com )
01807   {
01808     case CMD_DASH:        return "dash";
01809     case CMD_TURN:        return "turn";
01810     case CMD_TURNNECK:    return "turn_neck";
01811     case CMD_CHANGEVIEW:  return "change_view";
01812     case CMD_CATCH:       return "catch";
01813     case CMD_KICK:        return "kick";
01814     case CMD_MOVE:        return "move";
01815     case CMD_SENSEBODY:   return "sense_body";
01816     case CMD_SAY:         return "neck";
01817     case CMD_ILLEGAL:
01818     default:               return NULL;
01819 
01820   }
01821 }
01822 
01828 bool SoccerTypes::isPrimaryCommand( CommandT com )
01829 {
01830   return com == CMD_KICK || com == CMD_DASH || com == CMD_MOVE ||
01831          com == CMD_TURN || com == CMD_CATCH ;
01832 }
01833 
01834 
01839 char* SoccerTypes::getSideStr( SideT s )
01840 {
01841   switch( s )
01842   {
01843     case SIDE_LEFT:    return "l";
01844     case SIDE_RIGHT:   return "r";
01845     case SIDE_ILLEGAL:
01846     default:           return NULL;
01847   }
01848 }
01849 
01854 SideT SoccerTypes::getSideFromStr( char* str )
01855 {
01856   if( str[0] == 'l' )      return SIDE_LEFT;
01857   else if( str[0] == 'r' ) return SIDE_RIGHT;
01858   else                     return SIDE_ILLEGAL;
01859 
01860 }
01861 
01867 char* SoccerTypes::getBallStatusStr( BallStatusT bs )
01868 {
01869   switch( bs )
01870   {
01871     case BS_IN_FIELD:      return "in_field";
01872     case BS_GOAL_LEFT:     return "goal_left";
01873     case BS_GOAL_RIGHT:    return "goal_right";
01874     case BS_OUT_OF_FIELD:  return "out_of_field";
01875     default:               return NULL;
01876   }
01877 }
01878 
01883 BallStatusT SoccerTypes::getBallStatusFromStr( char* str )
01884 {
01885   switch( str[0] )
01886   {
01887     case 'i': return BS_IN_FIELD;
01888     case 'o': return BS_OUT_OF_FIELD;
01889     case 'g': return (str[5]=='l') ? BS_GOAL_LEFT : BS_GOAL_RIGHT;
01890     default:
01891               cout << "(SoccerTypes::getBallStatusFromStr) illegal status " <<
01892                       str << endl;
01893               return BS_ILLEGAL;
01894   }
01895 }
01896 
01897 
01898 /******************************************************************************/
01899 /********************** TESTING PURPOSES **************************************/
01900 /******************************************************************************/
01901 
01902 /*
01903 int main( void )
01904 {
01905   char* s = "(p \"1\" 3)";
01906 
01907       "(see 0 ((g r) 56.3 0) ((f c) 3.8 0 -0 0) ((f r t) 66 -31) ((f r b)
01908       66 31) ((f p r t) 44.7 -26) ((f p r c) 39.6 0) ((f p r
01909       b) 44.7 26) ((f g r t) 56.8 -7) ((f g r b) 56.8 7) ((f t
01910       r 40) 58.6 -41) ((f t r 50) 66.7 -35) ((f b r 40) 58.6
01911       41) ((f b r 50) 66.7 35) ((f r t 30) 68 -26) ((f r t 20)
01912       64.7 -18) ((f r t 10) 62.2 -9) ((f r 0) 61.6 0) ((f r b
01913       10) 62.2 9) ((f r b 20) 64.7 18) ((f r b 30) 68 26) ((b)
01914       3.7 0 0 0) ((P) 1.2 179) ((P) 0.6 179) ((p "1" 3) nan 0
01915       0 0 0 0) ((p "1" 4) nan 0 0 0 0 0) ((l r) 56.3 -89))";
01916   char *ptr = s;
01917   char buf[1023];
01918   printf("%s\n", ptr );
01919   ObjectT o = SoccerTypes::getObjectFromStr(&ptr, "1");
01920   printf("%d, %s\n", o, SoccerTypes::getObjectStr(buf,o,"1") );
01921 }
01922 
01923 
01924 int main( void )
01925 {
01926   Time t( 10, 0 );
01927   t.show();
01928   t.updateTime( 10 );
01929   t.show();
01930   t.updateTime( 10 );
01931   t.show();
01932   cout << t.isStopped();
01933   t.updateTime( 12 );
01934   t.show();
01935   t.updateTime( 12);
01936   t.setTimeStopped(2);
01937   Time t2( 12, 3 );
01938   cout << t.getTimeDifference( t2 ) << " " << t2.isStopped() << endl;
01939   cout << (t < t2 ) << ( t > t2 ) << ( t <= t2 ) << (t == t2 ) << endl;
01940 }
01941 
01942 */

Generated on Tue Jul 2 10:18:54 2002 for UvA Trilearn 2002 by doxygen1.2.12 written by Dimitri van Heesch, © 1997-2001