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,2001, 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 */
00049 #include <iostream.h>     // needed for outputsteam in showcerr
00050 #include <stdio.h>        // needed for sprintf
00051 #ifdef Solaris
00052   #include <strings.h>    // needed for strncmp
00053 #else
00054   #include <string.h>     // needed for strncmp
00055 #endif
00056 
00057 #include "SoccerTypes.h"
00058 #include "Parse.h"
00059 
00060 
00061 /******************************************************************************/
00062 /********************** CLASS TIME ********************************************/
00063 /******************************************************************************/
00064 
00069 Time::Time( int iTime, int iStopped )
00070 {
00071   m_iTime    = iTime;
00072   m_iStopped = iStopped;
00073 }
00074 
00081 bool Time::updateTime( int iTime )
00082 {
00083   if( m_iTime == iTime )
00084     m_iStopped++;
00085   else
00086   {
00087     m_iTime    = iTime;
00088     m_iStopped = 0;
00089   }
00090   return true;
00091 }
00092 
00097 bool Time::setTimeStopped( int iTime )
00098 {
00099   m_iStopped = iTime;
00100   return true;
00101 }
00102 
00106 int Time::getTime( )
00107 {
00108   return m_iTime;
00109 }
00110 
00114 int Time::getTimeStopped( )
00115 {
00116   return m_iStopped;
00117 }
00118 
00125 int Time::getTimeDifference( Time t )
00126 {
00127   if( getTime() < t.getTime() )
00128     return getTime() - t.getTime();
00129   else if( getTime() == t.getTime() )
00130     return getTimeStopped() - t.getTimeStopped();
00131   else
00132     return getTime() - t.getTime();
00133 }
00134 
00138 bool Time::isStopped( )
00139 {
00140   return m_iStopped != 0;
00141 }
00142 
00154 Time Time::getTimeAddedWith( int iCycles )
00155 {
00156   int iTime    = getTime();
00157   int iStopped = getTimeStopped();
00158 
00159   if( iCycles > 0 )                            // add cycles
00160   {
00161     if( iStopped > 0 )                         // time stopped
00162       iStopped += iCycles;                     // add it to stopped cycles
00163     else
00164       iTime    += iCycles;                     // otherwise add to normal time
00165   }
00166   else                                         // subtract cycles
00167   {
00168     if( iStopped > 0 && iStopped >= iCycles)   // time stopped and enough time
00169       iStopped += iCycles;                     // subtract cycle (iCycles=neg)
00170     else if( iStopped > 0 )                    // stopped but not enough time
00171     {
00172       iStopped = 0;                            // take as many as possible
00173       iCycles += iStopped;
00174       iTime   += iCycles;                      // and take rest from m_iTime
00175     }
00176     else                                       // time not stopped
00177       iTime   += iCycles;                      // take all from m_iTime
00178     if( iTime < 0 )
00179       iTime = 0;                               // negative time not possible
00180   }
00181   return Time( iTime, iStopped );
00182 }
00183 
00188 bool Time::addToTime( int iCycles )
00189 {
00190   *this = getTimeAddedWith( iCycles );
00191   return true;
00192 }
00193 
00198 void Time::show( ostream &os )
00199 {
00200   os << "(" << getTime() << "," << getTimeStopped() << ")";
00201 }
00202 
00208 Time Time::operator + ( const int &i )
00209 {
00210   return getTimeAddedWith( i );
00211 }
00212 
00219 Time Time::operator + ( Time t )
00220 {
00221   return Time( getTime() + t.getTime(), t.getTimeStopped() );
00222 }
00223 
00229 Time Time::operator - ( const int &i )
00230 {
00231   return getTimeAddedWith( -i );
00232 }
00233 
00238 int Time::operator - ( Time t )
00239 {
00240   return getTimeDifference( t );
00241 }
00242 
00247 void Time::operator = ( const int &i )
00248 {
00249   updateTime( i );
00250   setTimeStopped( 0 );
00251 }
00252 
00256 void Time::operator += ( const int &i )
00257 {
00258   addToTime( i );
00259 }
00260 
00266 void Time::operator += ( Time t )
00267 {
00268   updateTime    ( getTime() + t.getTime() );
00269   setTimeStopped( t.getTimeStopped()      );
00270 }
00271 
00276 void Time::operator -= ( const int &i )
00277 {
00278   addToTime( -i );
00279 }
00280 
00285 void Time::operator -= ( Time t )
00286 {
00287   updateTime    ( getTime() - t.getTime() );
00288   setTimeStopped( 0                       );
00289 }
00290 
00291 
00298 bool Time::operator != ( const int &i )
00299 {
00300   return getTimeDifference( Time(i, 0) ) != 0;
00301 }
00302 
00309 bool Time::operator != ( Time t )
00310 {
00311   return getTimeDifference( t ) != 0;
00312 }
00313 
00320 bool Time::operator == ( const int &i )
00321 {
00322   return !( *this != i );
00323 }
00324 
00330 bool Time::operator == ( Time t )
00331 {
00332   return !( *this != t );
00333 }
00334 
00340 bool Time::operator <  ( Time t )
00341 {
00342   return getTimeDifference( t ) < 0;
00343 }
00344 
00350 bool Time::operator <  ( const int  &i )
00351 {
00352   return Time( i, 0 ) >= *this ;
00353 }
00354 
00360 bool Time::operator <= ( Time t )
00361 {
00362   return ( *this < t ) || (*this == t );
00363 }
00364 
00371 bool Time::operator <= ( const int  &i )
00372 {
00373   return ( *this < i ) || (*this == i );
00374 }
00375 
00380 bool Time::operator >  ( Time t )
00381 {
00382   return !( *this <= t );
00383 }
00384 
00390 bool Time::operator >  ( const int  &i )
00391 {
00392   return !( *this <= i );
00393 }
00394 
00399 bool Time::operator >= ( Time t )
00400 {
00401   return !( *this < t );
00402 
00403 }
00404 
00411 bool Time::operator >= ( const int  &i )
00412 {
00413   return !( *this < i );
00414 }
00415 
00423 ostream& operator <<( ostream &os, Time t )
00424 {
00425   return os << "(" << t.getTime() << "," << t.getTimeStopped() << ")";
00426 }
00427 
00428 /******************************************************************************/
00429 /********************** CLASS SOCCERCOMMAND ***********************************/
00430 /******************************************************************************/
00431 
00432 
00442 SoccerCommand::SoccerCommand( CommandT com, double d1, double d2, double d3 )
00443 {
00444   // first initialize variables
00445   commandType = com;
00446   dPower      = UnknownDoubleValue;
00447   dAngle      = UnknownDoubleValue;
00448   va          = VA_ILLEGAL;
00449   vq          = VQ_ILLEGAL;
00450   iTimes      = 1;
00451   strcpy( str, "\0" );
00452   if( com == CMD_CHANGEVIEW )
00453     makeCommand( commandType, (ViewAngleT)d1, (ViewQualityT)d2 );
00454   else if( com != CMD_SAY )
00455     makeCommand( commandType, d1, d2, d3 );
00456 }
00457 
00462 SoccerCommand::SoccerCommand( CommandT com, char *msg )
00463 {
00464   makeCommand( com, msg )  ;
00465 }
00466 
00483 void SoccerCommand::makeCommand( CommandT com, double d1, double d2, double d3 )
00484 {
00485   // set the variables that have a meaning for the specified command type
00486   commandType = com;
00487   if( com == CMD_TURN || com == CMD_TURNNECK )
00488     dAngle = d1;
00489   else if( com == CMD_DASH )
00490     dPower = d1;
00491   else if( com == CMD_KICK )
00492   {
00493     dPower = d1;
00494     dAngle = d2;
00495   }
00496   else if( com == CMD_MOVE )
00497   {
00498     dX = d1;
00499     dY = d2;
00500     if( d3 != UnknownDoubleValue )
00501       dAngle = d3;
00502     else
00503       dAngle = 0;
00504   }
00505   else if( com == CMD_CATCH )
00506     dAngle = d1;
00507   else if( com == CMD_CHANGEPLAYER )
00508   {
00509     dX = d1;
00510     dY = d2;
00511   }
00512 }
00513 
00518 void SoccerCommand::makeCommand( CommandT com, ViewAngleT v, ViewQualityT q )
00519 {
00520   commandType = com;
00521   if( com == CMD_CHANGEVIEW )
00522   {
00523     va = (ViewAngleT)  v;
00524     vq = (ViewQualityT)q;
00525   }
00526 }
00527 
00532 void SoccerCommand::makeCommand( CommandT com, char* msg )
00533 {
00534   commandType = com;
00535   if( com == CMD_SAY )
00536      strcpy( str, msg );
00537 }
00538 
00541 void SoccerCommand::show( ostream& os )
00542 {
00543   os << "time: " << time << " "; // can be illegal when not yet set in WM.
00544   switch( commandType )
00545   {
00546     case CMD_ILLEGAL:
00547       os << "illegal\n" ;
00548       break;
00549     case CMD_DASH:
00550       os << "dash " << dPower << " times: " << iTimes << endl;
00551       break;
00552     case CMD_TURN:
00553     case CMD_TURNNECK:
00554       if( commandType == CMD_TURN )
00555         os << "turn " << dAngle << endl;
00556       else
00557         os << "turn_neck " << " " << dAngle << endl;
00558       break;
00559      case CMD_CHANGEVIEW:
00560       os << "change_view " <<
00561               SoccerTypes::getViewAngleStr( va ) << " " <<
00562               SoccerTypes::getViewQualityStr( vq ) << endl;
00563       break;
00564     case CMD_CATCH:
00565       os << "catch " << dAngle << endl;
00566       break;
00567     case CMD_KICK:
00568       os << "kick " << dPower << " " << dAngle << endl;
00569       break;
00570     case CMD_MOVE:
00571       os << "move " << dX << " " << dY << " " << dAngle << endl;
00572       break;
00573     case CMD_SENSEBODY:
00574       os << "sense_body" << endl;
00575       break;
00576     case CMD_SAY:
00577       os << "say " << str << endl;
00578       break;
00579     case CMD_CHANGEPLAYER:
00580       os << "change_player " << (int)dX << " " << (int)dY << endl;
00581       break;
00582     default:
00583       os << "unknown" << endl;
00584       break;
00585   }
00586 }
00587 
00592 bool SoccerCommand::isIllegal( )
00593 {
00594   return commandType == CMD_ILLEGAL;
00595 }
00596 
00604 char*  SoccerCommand::getCommandString( char *str, ServerSettings *ss )
00605 {
00606   SS = ss;
00607   bool b = false;
00608   switch( commandType )
00609   {
00610     case CMD_DASH:        b = makeDashCommand(         str ); break;
00611     case CMD_TURN:        b = makeTurnCommand(         str ); break;
00612     case CMD_TURNNECK:    b = makeTurnNeckCommand(     str ); break;
00613     case CMD_CHANGEVIEW:  b = makeChangeViewCommand(   str ); break;
00614     case CMD_CATCH:       b = makeCatchCommand(        str ); break;
00615     case CMD_KICK:        b = makeKickCommand(         str ); break;
00616     case CMD_MOVE:        b = makeMoveCommand(         str ); break;
00617     case CMD_SENSEBODY:   b = makeSenseBodyCommand(    str ); break;
00618     case CMD_SAY:         b = makeSayCommand(          str ); break;
00619     case CMD_CHANGEPLAYER:b = makeChangePlayerCommand( str ); break;
00620     case CMD_ILLEGAL:    str[0] = '\0';                       break;
00621     default:
00622       cerr << "(ActHandler::makeCommandString) Unkown command!"<<endl;
00623 
00624     if( b == false )                       // if string could not be created
00625     {
00626       commandType = CMD_ILLEGAL;
00627       str[0] = '\0';                       // create the empty string
00628     }
00629   }
00630   return str;
00631 }
00632 
00639 bool SoccerCommand::makeCatchCommand( char *str  )
00640 {
00641   if( SS->getMinMoment( ) <= dAngle && dAngle <= SS->getMaxMoment( ) )
00642     sprintf( str, "(catch %d)", (int)dAngle );
00643   else
00644   {
00645     printf("(SoccerCommand::makeCatchCommand) angle %f out of bounds\n",dAngle);
00646     return false;
00647   }
00648   return true;
00649 }
00650 
00657 bool SoccerCommand::makeChangeViewCommand( char *str  )
00658 {
00659   if( va != VA_ILLEGAL && vq != VQ_ILLEGAL )
00660     sprintf( str,"(change_view %s %s)", SoccerTypes::getViewAngleStr  ( va ),
00661                                         SoccerTypes::getViewQualityStr( vq ) );
00662   else
00663   {
00664     printf( "(SoccerCommand::makeChangeViewCommand) wrong arguments %s %s\n",
00665                              SoccerTypes::getViewAngleStr  ( va ),
00666                              SoccerTypes::getViewQualityStr( vq )  );
00667     return false;
00668   }
00669   return true;
00670 }
00671 
00678 bool SoccerCommand::makeDashCommand( char *str  )
00679 {
00680   if( SS->getMinPower() <= dPower && dPower <= SS->getMaxPower() )
00681     sprintf( str,"(dash %d)", (int)dPower );
00682   else
00683   {
00684     printf( "(SoccerCommand::makeDashCommand) power %d out of bounds (%d,%d)\n",
00685         (int)dPower, SS->getMinPower(), SS->getMaxPower() );
00686     dPower = 0.0;
00687     sprintf( str, "(dash 0)" );
00688     return false;
00689   }
00690   return true;
00691 }
00692 
00699 bool SoccerCommand::makeKickCommand( char *str  )
00700 {
00701   if( SS->getMinPower( )  <= dPower && dPower <= SS->getMaxPower( ) &&
00702       SS->getMinMoment( ) <= dAngle && dAngle <= SS->getMaxMoment( ) )
00703     sprintf( str,"(kick %d %d)", (int)dPower, (int)dAngle );
00704   else
00705   {
00706     printf("(SoccerCommand::makeKickCommand) one argument %d or %d is wrong\n",
00707                     (int)dPower, (int)dAngle );
00708     return false;
00709   }
00710   return true;
00711 }
00712 
00719 bool SoccerCommand::makeMoveCommand( char *str  )
00720 {
00721   if( -PITCH_LENGTH/2 - PITCH_MARGIN <= dX &&
00722        PITCH_LENGTH/2 + PITCH_MARGIN >= dX &&
00723       -PITCH_WIDTH/2  - PITCH_MARGIN <= dY &&
00724        PITCH_WIDTH/2  + PITCH_MARGIN >= dY   )
00725     sprintf( str,"(move %d %d)", (int)dX, (int)dY);
00726   else
00727   {
00728     printf( "(SoccerCommand::makeMoveCommand) one argument %d or %d is wrong\n",
00729                   (int)dX, (int)dY);
00730     return false;
00731   }
00732   return true;
00733 }
00734 
00741 bool SoccerCommand::makeSayCommand( char *str_com  )
00742 {
00743   if( str != NULL && str[0] != '\0' )
00744     sprintf( str_com, "(say %s)", str );
00745   else
00746   {
00747     printf( "(SoccerCommand::makeSayCommand) no string filled in\n" );
00748     return false;
00749   }
00750   return true;
00751 }
00752 
00758 bool SoccerCommand::makeSenseBodyCommand( char *str  )
00759 {
00760   sprintf( str,"(sense_body)" );
00761   return true;
00762 }
00763 
00770 bool SoccerCommand::makeTurnCommand( char *str  )
00771 {
00772   if( SS->getMinMoment( ) <= dAngle && dAngle <= SS->getMaxMoment( ) )
00773     sprintf( str,"(turn %d)", (int)dAngle );
00774   else
00775   {
00776     printf( "(SoccerCommand::makeTurnCommand) argument %d incorrect (%d, %d)\n",
00777       (int)dAngle, SS->getMinMoment( ), SS->getMaxMoment( ) );
00778     dAngle = 0.0;
00779     sprintf( str, "(turn 0)" );
00780     return false;
00781   }
00782   return true;
00783 }
00784 
00791 bool SoccerCommand::makeTurnNeckCommand( char *str  )
00792 {
00793   if( SS->getMinNeckMoment( ) <= (int)dAngle &&
00794       (int)dAngle             <= SS->getMaxNeckMoment( ) )
00795     sprintf( str,"(turn_neck %d)", (int)dAngle );
00796   else
00797   {
00798     printf( "(SoccerCommand::makeTurnNeckCommand) argument %d is wrong\n",
00799                                                      (int)dAngle );
00800     dAngle = 0.0;
00801     sprintf( str, "(turn_neck 0)" );
00802     return false;
00803   }
00804   return true;
00805 }
00806 
00816 bool SoccerCommand::makeChangePlayerCommand( char *str  )
00817 {
00818   if( (int)dX > 0  && (int)dX <= MAX_TEAMMATES &&
00819       (int)dY >= 0 && (int)dY < MAX_HETERO_PLAYERS  )
00820     sprintf( str,"(change_player_type %d %d)", (int)dX, (int)dY );
00821   else
00822   {
00823     printf( "(SoccerCommand::makeChangePlayerCommand) argument %d or %d is wrong\n",
00824                                                (int)dX, (int)dY  );
00825     return false;
00826   }
00827   return true;
00828 }
00829 
00830 /******************************************************************************/
00831 /********************** CLASS SOCCERTYPES *************************************/
00832 /******************************************************************************/
00833 
00838 const char * ObjectNames[] =
00839 {
00840 "(b)", "(g l)", "(g r)", "(g ?)", "(l l)", "(l r)", "(l b)", "(l t)", "(f l t)",    
00841 "(f t l 50)", "(f t l 40)", "(f t l 30)", "(f t l 20)", "(f t l 10)", "(f t 0)",
00842 "(f c t)",    "(f t r 10)", "(f t r 20)", "(f t r 30)", "(f t r 40)",
00843 "(f t r 50)", "(f r t)"   , "(f r t 30)", "(f r t 20)", "(f r t 10)",
00844 "(f g r t)" , "(f r 0)"   , "(f g r b)" , "(f r b 10)", "(f r b 20)",
00845 "(f r b 30)", "(f r b)"   , "(f b r 50)", "(f b r 40)", "(f b r 30)",
00846 "(f b r 20)", "(f b r 10)", "(f c b)"   , "(f b 0)"   , "(f b l 10)",
00847 "(f b l 20)", "(f b l 30)", "(f b l 40)", "(f b l 50)", "(f l b)",
00848 "(f l b 30)", "(f l b 20)", "(f l b 10)", "(f g l b)" , "(f l 0)",
00849 "(f g l t)" , "(f l t 10)", "(f l t 20)", "(f l t 30)", "(f p l t)",
00850 "(f p l c)", "(f p l b)",   "(f p r t)",  "(f p r c)",  "(f p r b)", "(f c)" } ;
00851 
00859 char* SoccerTypes::getObjectStr( char* strBuf, ObjectT o, const char *strTeamName )
00860 {
00861   if( o >= OBJECT_BALL && o <=   OBJECT_FLAG_C )
00862     sprintf( strBuf, ObjectNames[(int)o] );
00863   else if( isKnownPlayer( o ) )
00864     sprintf( strBuf, "(p %s %d)", strTeamName, getIndex( o ) + 1);
00865   else if( o == OBJECT_OPPONENT_UNKNOWN || o == OBJECT_TEAMMATE_UNKNOWN )
00866     sprintf( strBuf, "(p %s)", strTeamName );
00867   else if( o == OBJECT_PLAYER_UNKNOWN )
00868     sprintf( strBuf, "(p)" );
00869   else if( o == OBJECT_UNKNOWN )
00870     sprintf( strBuf, "(unknown)" );
00871   else
00872     sprintf( strBuf, "illegal: %d", (int)o );
00873   return strBuf;
00874 }
00875 
00885 ObjectT SoccerTypes::getObjectFromStr( char** str, bool *isGoalie,
00886                                        const char* strMyTeamName )
00887 {
00888   ObjectT o = OBJECT_ILLEGAL;
00889   char* ptrStr = *str;
00890   *isGoalie = false;
00891 
00892   switch( ptrStr[1] )
00893   {
00894     case 'b':                       // (ball)
00895     case 'B':                       // (B) in case of ball very close
00896        o = OBJECT_BALL; break;
00897     case 'G':
00898        o = OBJECT_GOAL_UNKNOWN;      // (G) in case of goal very close, ignored
00899       break;                        // (g l) or (g r) goal left or goal right
00900     case 'g': o = (ptrStr[3] == 'l') ? OBJECT_GOAL_L : OBJECT_GOAL_R; break;
00901     case 'l':                       // (l l), (l r), (l b) or (l t)
00902       switch( ptrStr[3] )
00903       {
00904         case 'l': o = OBJECT_LINE_L;  break;
00905         case 'r': o = OBJECT_LINE_R;  break;
00906         case 'b': o = OBJECT_LINE_B;  break;
00907         case 't': o = OBJECT_LINE_T;  break;
00908         default:  o = OBJECT_ILLEGAL; break;
00909       }
00910       break;
00911     case 'F':                       // (F) unkown flag very close.. ignored
00912       o = OBJECT_UNKNOWN; break;
00913     case 'f':                       // (f ...),  many options...
00914       switch( ptrStr[3] )
00915       {
00916         case 'l':                   // (f l ... lines on left part of field
00917           if( ptrStr[6] == ')' )    // only one character at index '5'
00918           {
00919             switch( ptrStr[5] )
00920             {
00921               case '0': o = OBJECT_FLAG_L_0; break; // (f l 0)
00922               case 't': o = OBJECT_FLAG_L_T; break; // (f l t)
00923               case 'b': o = OBJECT_FLAG_L_B; break; // (f l b)
00924               default:  o = OBJECT_ILLEGAL;  break;
00925             }
00926           }
00927           else                      // more than one character from index '5'
00928           {
00929             switch( ptrStr[7] )
00930             {
00931               case '1':             // (f l t 10) or (f l b 10)
00932                 o = (ptrStr[5]=='t')? OBJECT_FLAG_L_T_10 :OBJECT_FLAG_L_B_10;
00933                 break;
00934               case '2':             // (f l t 20) or (f l b 20)
00935                 o = (ptrStr[5]=='t')? OBJECT_FLAG_L_T_20 :OBJECT_FLAG_L_B_20;
00936                 break;
00937               case '3':             // (f l t 30) or (f l b 30)
00938                 o = (ptrStr[5]=='t')? OBJECT_FLAG_L_T_30 :OBJECT_FLAG_L_B_30;
00939                 break;
00940               default:
00941                 o = OBJECT_ILLEGAL;
00942                 break;
00943             }
00944           }
00945           break;
00946         case 'r':                   // (f r ... lines on right side of field
00947           if( ptrStr[6] == ')' )    // only one character at index '5'
00948           {
00949             switch( ptrStr[5] )
00950             {
00951               case '0': o = OBJECT_FLAG_R_0; break; // (f l 0)
00952               case 't': o = OBJECT_FLAG_R_T; break; // (f l t)
00953               case 'b': o = OBJECT_FLAG_R_B; break; // (f l b)
00954             }
00955           }
00956           else
00957           {
00958             switch( ptrStr[7] )     // more than one character from index '5'
00959             {
00960               case '1':
00961                 o = (ptrStr[5]=='t')? OBJECT_FLAG_R_T_10 :OBJECT_FLAG_R_B_10;
00962                 break;
00963               case '2':             // (f r t 10) or (f r b 10)
00964                 o = (ptrStr[5]=='t')? OBJECT_FLAG_R_T_20 :OBJECT_FLAG_R_B_20;
00965                 break;              // (f r t 20) or (f r b 20)
00966               case '3':
00967                 o = (ptrStr[5]=='t')? OBJECT_FLAG_R_T_30 :OBJECT_FLAG_R_B_30;
00968                 break;              // (f r t 30) or (f r b 30)
00969               default:
00970                 o = OBJECT_ILLEGAL;
00971                 break;
00972             }
00973           }
00974           break;
00975         case 't':                   // lines on top part of field
00976           if( ptrStr[5] == '0' )
00977             o = OBJECT_FLAG_T_0;    // (f t 0) center flag
00978           else
00979           {
00980             switch( ptrStr[7] )     // rest of the top flags
00981             {
00982               case '1':             // (f t l 10) or (f t r 10)
00983                 o = (ptrStr[5]=='l') ? OBJECT_FLAG_T_L_10 : OBJECT_FLAG_T_R_10;
00984                 break;
00985               case '2':             // (f t l 20) or (f t r 20)
00986                 o = (ptrStr[5]=='l') ? OBJECT_FLAG_T_L_20 : OBJECT_FLAG_T_R_20;
00987                 break;
00988               case '3':             // (f t l 30) or (f t r 30)
00989                 o = (ptrStr[5]=='l') ? OBJECT_FLAG_T_L_30 : OBJECT_FLAG_T_R_30;
00990                 break;
00991               case '4':             // (f t l 40) or (f t r 40)
00992                 o = (ptrStr[5]=='l') ? OBJECT_FLAG_T_L_40 : OBJECT_FLAG_T_R_40;
00993                 break;
00994               case '5':             // (f t l 50) or (f t r 50)
00995                 o = (ptrStr[5]=='l') ? OBJECT_FLAG_T_L_50 : OBJECT_FLAG_T_R_50;
00996                 break;
00997             }
00998           }
00999           break;
01000         case 'b':                   // lines on bottom part of field
01001           if( ptrStr[5] == '0')
01002             o = OBJECT_FLAG_B_0;    // (f b 0) center flag
01003           else
01004           {
01005             switch( ptrStr[7] )     // rest of the bottom flags
01006             {
01007               case '1':             // (f b l 10) or (f b r 10)
01008                 o = (ptrStr[5]=='l') ? OBJECT_FLAG_B_L_10 : OBJECT_FLAG_B_R_10;
01009                 break;
01010               case '2':             // (f b l 20) or (f b r 20)
01011                 o = (ptrStr[5]=='l') ? OBJECT_FLAG_B_L_20 : OBJECT_FLAG_B_R_20;
01012                 break;
01013               case '3':             // (f b l 30) or (f b r 30)
01014                 o = (ptrStr[5]=='l') ? OBJECT_FLAG_B_L_30 : OBJECT_FLAG_B_R_30;
01015                 break;
01016               case '4':             // (f b l 40) or (f b r 40)
01017                 o = (ptrStr[5]=='l') ? OBJECT_FLAG_B_L_40 : OBJECT_FLAG_B_R_40;
01018                 break;
01019               case '5':             // (f b l 50) or (f b r 50)
01020                 o = (ptrStr[5]=='l') ? OBJECT_FLAG_B_L_50 : OBJECT_FLAG_B_R_50;
01021                 break;
01022             }
01023           }
01024           break;
01025         case 'c':                   // center flags
01026           if( ptrStr[4] == ')' )
01027             o = OBJECT_FLAG_C;      // (f c) flag in midpoint field
01028           else                      // (f c t) or (f c b)
01029             o = (ptrStr[5] == 't') ? OBJECT_FLAG_C_T : OBJECT_FLAG_C_B;
01030           break;
01031         case 'g':                   // goal flags
01032           if( ptrStr[5] == 'l' )    // (g l t) or (g l b)
01033             o = (ptrStr[7] == 't') ? OBJECT_FLAG_G_L_T : OBJECT_FLAG_G_L_B;
01034           else                      // (g r t) or (g r b)
01035             o = (ptrStr[7] == 't') ? OBJECT_FLAG_G_R_T : OBJECT_FLAG_G_R_B;
01036           break;
01037         case 'p':                   // flags at sides penalty area
01038           switch( ptrStr[7] )
01039           {
01040             case 't':               // (p l t) or (p r t) top penalty area
01041               o = (ptrStr[5] == 'l') ? OBJECT_FLAG_P_L_T : OBJECT_FLAG_P_R_T;
01042               break;
01043             case 'c':               // (p l c) or (p r c) center penalty area
01044               o = (ptrStr[5] == 'l') ? OBJECT_FLAG_P_L_C : OBJECT_FLAG_P_R_C;
01045               break;
01046             case 'b':               // (p l b) or (p r b) bottom penalty area
01047               o = (ptrStr[5] == 'l') ? OBJECT_FLAG_P_L_B : OBJECT_FLAG_P_R_B;
01048               break;
01049             default:
01050               o = OBJECT_ILLEGAL;
01051               break;
01052           }
01053           break;
01054         default:
01055           o = OBJECT_ILLEGAL;
01056       }
01057       break; // end flags (finally)
01058   case 'p': // (p team nr) or (p team) or (p) player teammate or opponent
01059   case 'P': // or (P)
01060     ptrStr += 2;
01061 
01062 
01063     if( Parse::gotoFirstSpaceOrClosingBracket(&ptrStr) == ')' )
01064       o = OBJECT_PLAYER_UNKNOWN; // if (p) or (P) player is unknown.
01065     // check also with quotes since later versions use string around "teamname"
01066     else if( strncmp( ptrStr+1, strMyTeamName, strlen( strMyTeamName ) ) == 0 ||
01067              strncmp( ptrStr+2, strMyTeamName, strlen( strMyTeamName ) ) == 0 )
01068     {
01069       ptrStr++;
01070       if( Parse::gotoFirstSpaceOrClosingBracket(&ptrStr) == ' ' )
01071       {                                               // also team number
01072         switch( Parse::parseFirstInt( &ptrStr ) )     // get team number
01073         {
01074           case 1:  o = OBJECT_TEAMMATE_1;  break;     // and find team member
01075           case 2:  o = OBJECT_TEAMMATE_2;  break;
01076           case 3:  o = OBJECT_TEAMMATE_3;  break;
01077           case 4:  o = OBJECT_TEAMMATE_4;  break;
01078           case 5:  o = OBJECT_TEAMMATE_5;  break;
01079           case 6:  o = OBJECT_TEAMMATE_6;  break;
01080           case 7:  o = OBJECT_TEAMMATE_7;  break;
01081           case 8:  o = OBJECT_TEAMMATE_8;  break;
01082           case 9:  o = OBJECT_TEAMMATE_9;  break;
01083           case 10: o = OBJECT_TEAMMATE_10; break;
01084           case 11: o = OBJECT_TEAMMATE_11; break;
01085           default: o = OBJECT_ILLEGAL;
01086         }
01087         if( ptrStr[0] != ')' && ptrStr[1] == 'g' ) // goalie
01088           *isGoalie = true;
01089       }
01090       else
01091         o = OBJECT_TEAMMATE_UNKNOWN;                  // (p team) but no nr
01092     }
01093     else                                              // not a teammate
01094     {
01095       ptrStr++;
01096       if( Parse::gotoFirstSpaceOrClosingBracket( &ptrStr ) == ' ' )
01097       {                                               // also team number
01098         switch( Parse::parseFirstInt( &ptrStr ) )     // get team numer
01099         {
01100           case 1:  o = OBJECT_OPPONENT_1;  break;     // and return opponent
01101           case 2:  o = OBJECT_OPPONENT_2;  break;
01102           case 3:  o = OBJECT_OPPONENT_3;  break;
01103           case 4:  o = OBJECT_OPPONENT_4;  break;
01104           case 5:  o = OBJECT_OPPONENT_5;  break;
01105           case 6:  o = OBJECT_OPPONENT_6;  break;
01106           case 7:  o = OBJECT_OPPONENT_7;  break;
01107           case 8:  o = OBJECT_OPPONENT_8;  break;
01108           case 9:  o = OBJECT_OPPONENT_9;  break;
01109           case 10: o = OBJECT_OPPONENT_10; break;
01110           case 11: o = OBJECT_OPPONENT_11; break;
01111           default: o = OBJECT_ILLEGAL;
01112         }
01113         if( ptrStr[0] != ')' && ptrStr[1] == 'g' ) // goalie
01114           *isGoalie = true;
01115       }
01116       else
01117         o = OBJECT_OPPONENT_UNKNOWN;                  // number not known
01118 
01119     }
01120     break;
01121   default:
01122     cerr << "(SoccerTypes::getObjectFromStr) Unknown msg: " <<  ptrStr << endl;
01123     char buf[1000];
01124     printf("%d, %s\n", o, SoccerTypes::getObjectStr(buf,o,"1") );
01125     break;
01126   }
01127   // go to the end of the object
01128   Parse::gotoFirstOccurenceOf( ')', &ptrStr );
01129   *str=ptrStr;
01130   return o;
01131 }
01132 
01139 int SoccerTypes::getIndex( ObjectT o )
01140 {
01141   if( o >= OBJECT_OPPONENT_1 && o <= OBJECT_OPPONENT_11 )
01142     return o - OBJECT_OPPONENT_1;
01143   else if( o >= OBJECT_TEAMMATE_1 && o <= OBJECT_TEAMMATE_11 )
01144     return o - OBJECT_TEAMMATE_1;
01145   else if( o >= OBJECT_GOAL_L && o <= OBJECT_GOAL_R )
01146     return o - OBJECT_GOAL_L;
01147   else if( o >= OBJECT_FLAG_L_T && o <= OBJECT_FLAG_C )
01148     return o - OBJECT_FLAG_L_T + 2; // 2 added for the two goals
01149   else if( o >= OBJECT_LINE_L && o <= OBJECT_LINE_T )
01150     return o - OBJECT_LINE_L;
01151   else
01152     return -1;
01153 }
01154 
01159 ObjectT SoccerTypes::getTeammateObjectFromIndex( int iIndex )
01160 {
01161   return (ObjectT) ( OBJECT_TEAMMATE_1 + iIndex );
01162 }
01163 
01168 ObjectT SoccerTypes::getOpponentObjectFromIndex( int iIndex )
01169 {
01170   return (ObjectT) ( OBJECT_OPPONENT_1 + iIndex );
01171 }
01172 
01179 bool SoccerTypes::isInSet( ObjectT o, ObjectSetT o_g )
01180 {
01181   switch( o_g )
01182   {
01183     case OBJECT_SET_TEAMMATES: return isTeammate( o ) && isKnownPlayer( o );
01184     case OBJECT_SET_OPPONENTS: return isOpponent( o ) && isKnownPlayer( o );
01185     case OBJECT_SET_PLAYERS:   return isPlayer  ( o ) && isKnownPlayer( o );
01186     case OBJECT_SET_FLAGS:     return isFlag    ( o );
01187     case OBJECT_SET_LINES:     return isLine    ( o );
01188     case OBJECT_SET_ILLEGAL:
01189     default:                   return false;
01190   }
01191   return false;
01192 }
01196 bool SoccerTypes::isFlag( ObjectT o )
01197 {
01198   return ( o >= OBJECT_FLAG_L_T && o <= OBJECT_FLAG_C ) ||
01199          ( o >= OBJECT_GOAL_L   && o <= OBJECT_GOAL_R        );
01200 }
01201 
01205 bool SoccerTypes::isLine( ObjectT o )
01206 {
01207   return o >= OBJECT_LINE_L && o <= OBJECT_LINE_T;
01208 }
01209 
01213 bool SoccerTypes::isGoal( ObjectT o )
01214 {
01215   return o == OBJECT_GOAL_L || o == OBJECT_GOAL_R;
01216 }
01217 
01221 bool SoccerTypes::isTeammate( ObjectT o )
01222 {
01223   return o >= OBJECT_TEAMMATE_1 && o <= OBJECT_TEAMMATE_UNKNOWN;
01224 }
01225 
01229 bool SoccerTypes::isOpponent( ObjectT o )
01230 {
01231   return o >= OBJECT_OPPONENT_1 && o <= OBJECT_OPPONENT_UNKNOWN;
01232 }
01233 
01238 bool SoccerTypes::isPlayer( ObjectT o )
01239 {
01240   return isKnownPlayer( o )           || o == OBJECT_TEAMMATE_UNKNOWN ||
01241          o == OBJECT_OPPONENT_UNKNOWN || o == OBJECT_PLAYER_UNKNOWN;
01242 }
01243 
01248 bool SoccerTypes::isKnownPlayer( ObjectT o )
01249 {
01250   return (o >= OBJECT_OPPONENT_1 && o <= OBJECT_OPPONENT_11) ||
01251          (o >= OBJECT_TEAMMATE_1 && o <= OBJECT_TEAMMATE_11);
01252 }
01253 
01258 bool SoccerTypes::isGoalie( ObjectT o )
01259 {
01260   return o == OBJECT_TEAMMATE_1 || o == OBJECT_OPPONENT_1;
01261 }
01262 
01266 bool SoccerTypes::isBall( ObjectT o )
01267 {
01268   return o == OBJECT_BALL;
01269 }
01270 
01274 ObjectT SoccerTypes::getOwnGoal( SideT s )
01275 {
01276   if( SIDE_LEFT == s )
01277     return OBJECT_GOAL_L;
01278   else if( SIDE_RIGHT == s )
01279     return OBJECT_GOAL_R;
01280 
01281   cerr << "(SoccerTypes::isOwnGoal) Wrong side argument" << endl;
01282   return OBJECT_ILLEGAL;
01283 }
01284 
01288 ObjectT SoccerTypes::getGoalOpponent( SideT s )
01289 {
01290   if( SIDE_LEFT == s )
01291     return OBJECT_GOAL_R;
01292   else if( SIDE_RIGHT == s )
01293     return OBJECT_GOAL_L;
01294 
01295   cerr << "(SoccerTypes::isGoalOpponent) Wrong side argument" << endl;
01296   return OBJECT_ILLEGAL;
01297 }
01298 
01308 VecPosition SoccerTypes::getGlobalPositionFlag( ObjectT o, SideT s,
01309                                                              double dGoalWidth )
01310 {
01311   VecPosition pos;
01312   if( !(isFlag(o) || isGoal(o)) )
01313       return VecPosition(UnknownDoubleValue, UnknownDoubleValue);
01314   switch( o ) // for every object the global position is entered
01315   {
01316     case OBJECT_GOAL_L:
01317       pos.setVecPosition( -PITCH_LENGTH/2.0, 0.0 );                  break;
01318     case OBJECT_GOAL_R:
01319       pos.setVecPosition(  PITCH_LENGTH/2.0, 0.0 );                  break;
01320     case OBJECT_FLAG_L_T:
01321       pos.setVecPosition( -PITCH_LENGTH/2.0, -PITCH_WIDTH/2.0 );     break;
01322     case OBJECT_FLAG_T_L_50:
01323       pos.setVecPosition( -50.0, -PITCH_WIDTH/2.0 - PITCH_MARGIN );  break;
01324     case OBJECT_FLAG_T_L_40:
01325       pos.setVecPosition( -40.0, -PITCH_WIDTH/2.0 - PITCH_MARGIN );  break;
01326     case OBJECT_FLAG_T_L_30:
01327       pos.setVecPosition( -30.0, -PITCH_WIDTH/2.0 - PITCH_MARGIN );  break;
01328     case OBJECT_FLAG_T_L_20:
01329       pos.setVecPosition( -20.0, -PITCH_WIDTH/2.0 - PITCH_MARGIN );  break;
01330     case OBJECT_FLAG_T_L_10:
01331       pos.setVecPosition( -10.0, -PITCH_WIDTH/2.0 - PITCH_MARGIN );  break;
01332     case OBJECT_FLAG_T_0:
01333       pos.setVecPosition(   0.0, -PITCH_WIDTH/2.0 - PITCH_MARGIN );  break;
01334     case OBJECT_FLAG_C_T:
01335       pos.setVecPosition(   0.0, -PITCH_WIDTH/2.0);                  break;
01336     case OBJECT_FLAG_T_R_10:
01337       pos.setVecPosition(  10.0,  -PITCH_WIDTH/2.0 - PITCH_MARGIN);  break;
01338     case OBJECT_FLAG_T_R_20:
01339       pos.setVecPosition(  20.0,  -PITCH_WIDTH/2.0 - PITCH_MARGIN);  break;
01340     case OBJECT_FLAG_T_R_30:
01341       pos.setVecPosition(  30.0,  -PITCH_WIDTH/2.0 - PITCH_MARGIN);  break;
01342     case OBJECT_FLAG_T_R_40:
01343       pos.setVecPosition(  40.0,  -PITCH_WIDTH/2.0 - PITCH_MARGIN);  break;
01344     case OBJECT_FLAG_T_R_50:
01345       pos.setVecPosition(  50.0,  -PITCH_WIDTH/2.0 - PITCH_MARGIN);  break;
01346     case OBJECT_FLAG_R_T:
01347       pos.setVecPosition( PITCH_LENGTH/2.0,  -PITCH_WIDTH/2.0 );     break;
01348     case OBJECT_FLAG_R_T_30:
01349       pos.setVecPosition( PITCH_LENGTH/2.0 + PITCH_MARGIN,  -30.0 ); break;
01350     case OBJECT_FLAG_R_T_20:
01351       pos.setVecPosition( PITCH_LENGTH/2.0 + PITCH_MARGIN,  -20.0 ); break;
01352     case OBJECT_FLAG_R_T_10:
01353       pos.setVecPosition( PITCH_LENGTH/2.0 + PITCH_MARGIN,  -10.0 ); break;
01354     case OBJECT_FLAG_G_R_T:
01355       pos.setVecPosition( PITCH_LENGTH/2.0,  -dGoalWidth/2.0 );      break;
01356     case OBJECT_FLAG_R_0:
01357       pos.setVecPosition( PITCH_LENGTH/2.0 + PITCH_MARGIN,  0.0 );   break;
01358     case OBJECT_FLAG_G_R_B:
01359       pos.setVecPosition( PITCH_LENGTH/2.0,  dGoalWidth/2.0 );       break;
01360     case OBJECT_FLAG_R_B_10:
01361       pos.setVecPosition( PITCH_LENGTH/2.0 + PITCH_MARGIN,  10.0 );  break;
01362     case OBJECT_FLAG_R_B_20:
01363       pos.setVecPosition( PITCH_LENGTH/2.0 + PITCH_MARGIN,  20.0 );  break;
01364     case OBJECT_FLAG_R_B_30:
01365       pos.setVecPosition( PITCH_LENGTH/2.0 + PITCH_MARGIN,  30.0 );  break;
01366     case OBJECT_FLAG_R_B:
01367       pos.setVecPosition( PITCH_LENGTH/2.0,  PITCH_WIDTH/2.0 );      break;
01368     case OBJECT_FLAG_B_R_50:
01369       pos.setVecPosition(  50.0, PITCH_WIDTH/2.0 + PITCH_MARGIN );   break;
01370     case OBJECT_FLAG_B_R_40:
01371       pos.setVecPosition(  40.0, PITCH_WIDTH/2.0 + PITCH_MARGIN );   break;
01372     case OBJECT_FLAG_B_R_30:
01373       pos.setVecPosition(  30.0, PITCH_WIDTH/2.0 + PITCH_MARGIN );   break;
01374     case OBJECT_FLAG_B_R_20:
01375       pos.setVecPosition(  20.0, PITCH_WIDTH/2.0 + PITCH_MARGIN );   break;
01376     case OBJECT_FLAG_B_R_10:
01377       pos.setVecPosition(  10.0, PITCH_WIDTH/2.0 + PITCH_MARGIN );   break;
01378     case OBJECT_FLAG_C_B:
01379       pos.setVecPosition(   0.0, PITCH_WIDTH/2.0 );                  break;
01380     case OBJECT_FLAG_B_0:
01381       pos.setVecPosition(   0.0, PITCH_WIDTH/2.0 + PITCH_MARGIN );   break;
01382     case OBJECT_FLAG_B_L_10:
01383       pos.setVecPosition( -10.0, PITCH_WIDTH/2.0 + PITCH_MARGIN );   break;
01384     case OBJECT_FLAG_B_L_20:
01385       pos.setVecPosition( -20.0, PITCH_WIDTH/2.0 + PITCH_MARGIN );   break;
01386     case OBJECT_FLAG_B_L_30:
01387       pos.setVecPosition( -30.0, PITCH_WIDTH/2.0 + PITCH_MARGIN );   break;
01388     case OBJECT_FLAG_B_L_40:
01389       pos.setVecPosition( -40.0, PITCH_WIDTH/2.0 + PITCH_MARGIN );   break;
01390     case OBJECT_FLAG_B_L_50:
01391       pos.setVecPosition( -50.0, PITCH_WIDTH/2.0 + PITCH_MARGIN );   break;
01392     case OBJECT_FLAG_L_B:
01393       pos.setVecPosition( -PITCH_LENGTH/2.0,  PITCH_WIDTH/2.0 );     break;
01394     case OBJECT_FLAG_L_B_30:
01395       pos.setVecPosition( -PITCH_LENGTH/2.0 - PITCH_MARGIN,  30.0 ); break;
01396     case OBJECT_FLAG_L_B_20:
01397       pos.setVecPosition( -PITCH_LENGTH/2.0 - PITCH_MARGIN,  20.0 ); break;
01398     case OBJECT_FLAG_L_B_10:
01399       pos.setVecPosition( -PITCH_LENGTH/2.0 - PITCH_MARGIN,  10.0 ); break;
01400     case OBJECT_FLAG_G_L_B:
01401       pos.setVecPosition( -PITCH_LENGTH/2.0,  dGoalWidth/2.0 );      break;
01402     case OBJECT_FLAG_L_0:
01403       pos.setVecPosition( -PITCH_LENGTH/2.0 - PITCH_MARGIN,  0.0 );  break;
01404     case OBJECT_FLAG_G_L_T:
01405       pos.setVecPosition( -PITCH_LENGTH/2.0,  -dGoalWidth/2.0 );     break;
01406     case OBJECT_FLAG_L_T_10:
01407       pos.setVecPosition( -PITCH_LENGTH/2.0 - PITCH_MARGIN, -10.0 ); break;
01408     case OBJECT_FLAG_L_T_20:
01409       pos.setVecPosition( -PITCH_LENGTH/2.0 - PITCH_MARGIN, -20.0 ); break;
01410     case OBJECT_FLAG_L_T_30:
01411       pos.setVecPosition( -PITCH_LENGTH/2.0 - PITCH_MARGIN, -30.0 ); break;
01412     case OBJECT_FLAG_P_L_T:
01413       pos.setVecPosition( -PITCH_LENGTH/2.0 + PENALTY_AREA_LENGTH,
01414                                          - PENALTY_AREA_WIDTH/2.0 ); break;
01415     case OBJECT_FLAG_P_L_C:
01416       pos.setVecPosition( -PITCH_LENGTH/2.0 + PENALTY_AREA_LENGTH, 0.0 ); break;
01417     case OBJECT_FLAG_P_L_B:
01418       pos.setVecPosition( -PITCH_LENGTH/2.0 + PENALTY_AREA_LENGTH,
01419                                            PENALTY_AREA_WIDTH/2.0 ); break;
01420     case OBJECT_FLAG_P_R_T:
01421       pos.setVecPosition(  PITCH_LENGTH/2.0 - PENALTY_AREA_LENGTH,
01422                                           -PENALTY_AREA_WIDTH/2.0 ); break;
01423     case OBJECT_FLAG_P_R_C:
01424       pos.setVecPosition(  PITCH_LENGTH/2.0 - PENALTY_AREA_LENGTH, 0.0 ); break;
01425     case OBJECT_FLAG_P_R_B:
01426       pos.setVecPosition(  PITCH_LENGTH/2.0 - PENALTY_AREA_LENGTH,
01427                                            PENALTY_AREA_WIDTH/2.0 ); break;
01428     case OBJECT_FLAG_C:
01429       pos.setVecPosition(  0.0 , 0.0 );                              break;
01430     default:
01431       cerr << "(SoccerTypes::getGlobalPositionObject) wrong objecttype! " <<
01432         (int)o << endl ;
01433   }
01434 
01435   if( s == SIDE_RIGHT ) // change side for team on the right side.
01436       pos.setVecPosition( -pos.getX(), -pos.getY() );
01437   return pos;
01438 }
01439 
01448 AngDeg SoccerTypes::getGlobalAngleLine( ObjectT o , SideT s )
01449 {
01450   AngDeg angle = UnknownAngleValue;
01451   switch( o )
01452   {
01453     case OBJECT_LINE_L: angle = 180.0; break;
01454     case OBJECT_LINE_R: angle =   0.0; break;
01455     case OBJECT_LINE_T: angle = -90.0; break;
01456     case OBJECT_LINE_B: angle =  90.0; break;
01457   default:
01458     cerr << "(SoccerTypes::getGlobalAngleLine) wrong objecttype! " <<
01459       (int)o << endl;
01460     return UnknownAngleValue;
01461   }
01462 
01463   if( s == SIDE_RIGHT )
01464     angle += 180;
01465 
01466   return VecPosition::normalizeAngle( angle );
01467 }
01468 
01473 char* SoccerTypes::getPlayModeStr( PlayModeT pm )
01474 {
01475   switch( pm )
01476   {
01477     case PM_BEFORE_KICK_OFF:   return "before_kick_off";
01478     case PM_KICK_OFF_LEFT:     return "kick_off_l";
01479     case PM_KICK_OFF_RIGHT:    return "kick_off_r";
01480     case PM_KICK_IN_LEFT:      return "kick_in_l";
01481     case PM_KICK_IN_RIGHT:     return "kick_in_r";
01482     case PM_CORNER_KICK_LEFT:  return "corner_kick_l";
01483     case PM_CORNER_KICK_RIGHT: return "corner_kick_r";
01484     case PM_GOAL_KICK_LEFT:    return "goal_kick_l";
01485     case PM_GOAL_KICK_RIGHT:   return "goal_kick_r";
01486     case PM_GOAL_LEFT:         return "goal_r";
01487     case PM_GOAL_RIGHT:        return "goal_l";
01488     case PM_FREE_KICK_LEFT:    return "free_kick_l";
01489     case PM_FREE_KICK_RIGHT:   return "free_kick_r";
01490     case PM_PLAY_ON:           return "play_on";
01491     case PM_FROZEN:            return "play_off";
01492     case PM_QUIT:              return "quit";
01493     case PM_ILLEGAL:
01494     default:                   return NULL;
01495    }
01496 }
01497 
01501 PlayModeT SoccerTypes::getPlayModeFromStr( char* str )
01502 {
01503   // all play modes are sent as referee message, so get referee message
01504   // and look up the associated play mode
01505   return getPlayModeFromRefereeMessage( getRefereeMessageFromStr( str ) );
01506 }
01507 
01511 PlayModeT SoccerTypes::getPlayModeFromRefereeMessage( RefereeMessageT rm )
01512 {
01513   switch( rm )
01514   {
01515     case REFC_BEFORE_KICK_OFF:        return PM_BEFORE_KICK_OFF;
01516     case REFC_KICK_OFF_LEFT:          return PM_KICK_OFF_LEFT;
01517     case REFC_KICK_OFF_RIGHT:         return PM_KICK_OFF_RIGHT;
01518     case REFC_KICK_IN_LEFT:           return PM_KICK_IN_LEFT;
01519     case REFC_KICK_IN_RIGHT:          return PM_KICK_IN_RIGHT;
01520     case REFC_CORNER_KICK_LEFT:       return PM_CORNER_KICK_LEFT;
01521     case REFC_CORNER_KICK_RIGHT:      return PM_CORNER_KICK_RIGHT;
01522     case REFC_GOAL_KICK_LEFT:         return PM_GOAL_KICK_LEFT;
01523     case REFC_GOAL_KICK_RIGHT:        return PM_GOAL_KICK_RIGHT;
01524     case REFC_FREE_KICK_LEFT:         return PM_FREE_KICK_LEFT;
01525     case REFC_FREE_KICK_RIGHT:        return PM_FREE_KICK_RIGHT;
01526     case REFC_FOUL_LEFT:              return PM_FREE_KICK_RIGHT;
01527     case REFC_FOUL_RIGHT:             return PM_FREE_KICK_LEFT;
01528     case REFC_OFFSIDE_LEFT:           return PM_OFFSIDE_LEFT;
01529     case REFC_OFFSIDE_RIGHT:          return PM_OFFSIDE_RIGHT;
01530     case REFC_GOAL_LEFT:              return PM_GOAL_LEFT;
01531     case REFC_GOAL_RIGHT:             return PM_GOAL_RIGHT;
01532     case REFC_PLAY_ON:                return PM_PLAY_ON;
01533     case REFC_FROZEN:                 return PM_FROZEN;
01534     case REFC_TIME_OVER:              return PM_TIME_OVER;
01535     case REFC_QUIT:                   return PM_QUIT;
01536     default:                          return PM_ILLEGAL;
01537   }
01538 }
01539 
01544 char* SoccerTypes::getRefereeMessageStr( RefereeMessageT rm )
01545 {
01546   switch( rm )
01547   {
01548     case REFC_BEFORE_KICK_OFF:        return "before_kick_off";
01549     case REFC_KICK_OFF_LEFT:          return "kick_off_l";
01550     case REFC_KICK_OFF_RIGHT:         return "kick_off_r";
01551     case REFC_KICK_IN_LEFT:           return "kick_in_l";
01552     case REFC_KICK_IN_RIGHT:          return "kick_in_r";
01553     case REFC_CORNER_KICK_LEFT:       return "corner_kick_l";
01554     case REFC_CORNER_KICK_RIGHT:      return "corner_kick_r";
01555     case REFC_GOAL_KICK_LEFT:         return "goal_kick_l";
01556     case REFC_GOAL_KICK_RIGHT:        return "goal_kick_r";
01557     case REFC_FREE_KICK_LEFT:         return "free_kick_l";
01558     case REFC_FREE_KICK_RIGHT:        return "free_kick_r";
01559     case REFC_PLAY_ON:                return "play_on";
01560     case REFC_FROZEN:                 return "play_off";
01561     case REFC_QUIT:                   return "quit";
01562     case REFC_OFFSIDE_LEFT:           return "offside_l";
01563     case REFC_OFFSIDE_RIGHT:          return "offside_r";
01564     case REFC_HALF_TIME:              return "half_time";
01565     case REFC_TIME_UP:                return "time_up";
01566     case REFC_TIME_OVER:              return "time_over";
01567     case REFC_TIME_UP_WITHOUT_A_TEAM: return "time_up_without_a_team";
01568     case REFC_TIME_EXTENDED:          return "time_extended";
01569     case REFC_FOUL_LEFT:              return "foul_l";
01570     case REFC_FOUL_RIGHT:             return "foul_r";
01571     case REFC_GOAL_LEFT:              return "goal_l";
01572     case REFC_GOAL_RIGHT:             return "goal_r";
01573     case REFC_DROP_BALL:              return "drop_ball";
01574     case REFC_GOALIE_CATCH_BALL_LEFT: return "goalie_catch_ball_l";
01575     case REFC_GOALIE_CATCH_BALL_RIGHT:return "goalie_catch_ball_r";
01576     case REFC_ILLEGAL:
01577     default:                          return NULL;
01578   }
01579 }
01580 
01581 
01585 RefereeMessageT SoccerTypes::getRefereeMessageFromStr( char* str )
01586 {
01587   switch( str[0] )
01588   {
01589     case 'b':                   // before_kick_off
01590       return REFC_BEFORE_KICK_OFF;
01591     case 'c':                   // corner_kick_l or corner_kick_r
01592       return (str[12] == 'l') ? REFC_CORNER_KICK_LEFT : REFC_CORNER_KICK_RIGHT;
01593     case 'd':                   // drop_ball
01594       return REFC_DROP_BALL;
01595     case 'g':
01596       switch( str[5] )
01597       {
01598         case 'k':              // goal_kick_l, goal_kick_r
01599           return (str[10] == 'l') ? REFC_GOAL_KICK_LEFT : REFC_GOAL_KICK_RIGHT;
01600         case 'e':              // goalie_catch_ball_l, goalie_catch_ball_r
01601           return (str[18] == 'l') ? REFC_GOALIE_CATCH_BALL_LEFT
01602                                   : REFC_GOALIE_CATCH_BALL_RIGHT;
01603         case 'l':              // goal_l
01604           return REFC_GOAL_LEFT;
01605         case 'r':              // goal_r
01606           return REFC_GOAL_RIGHT;
01607       }
01608     case 'h':                  // half_time
01609       return REFC_HALF_TIME;
01610     case 'f':
01611       if( str[5] == 'k' )      // free_kick_l, free_kick_r
01612         return ( str[10] == 'l' ) ? REFC_FREE_KICK_LEFT : REFC_FREE_KICK_RIGHT;
01613       else if( str[5] == 'l' ) // foul_l
01614         return REFC_FOUL_LEFT;
01615       else if( str[5] == 'r' ) // foul_r
01616         return REFC_FOUL_RIGHT;
01617     case 'k':                  // kick_in_l, kick_in_r, kick_off_l, kick_off_r
01618       if( str[5] == 'i' )
01619         return (str[8] == 'l' )   ? REFC_KICK_IN_LEFT   : REFC_KICK_IN_RIGHT;
01620       else if( str[5] == 'o' )
01621         return (str[9] == 'l' )   ? REFC_KICK_OFF_LEFT  : REFC_KICK_OFF_RIGHT;
01622     case 'o':
01623       return ( str[8] == 'l' )    ? REFC_OFFSIDE_LEFT   : REFC_OFFSIDE_RIGHT;
01624     case 'p':                  // play_on
01625       return REFC_PLAY_ON;
01626     case 't':
01627       if( str[5] == 'o' )      // time_over
01628         return REFC_TIME_OVER;
01629       else if( str[5] == 'e' ) // time_extended
01630         return REFC_TIME_EXTENDED;
01631       else if( str[5] == 'u' ) // time_up
01632         return REFC_TIME_UP;
01633       else if( str[8] == 'w' ) // time_up_without_a_team
01634         return REFC_TIME_UP_WITHOUT_A_TEAM;
01635     default:
01636       printf("(SoccerTypes::getRefereeMessageFromStr) ?? ref msg %s\n",str);
01637       return REFC_ILLEGAL;
01638   }
01639 }
01640 
01641 
01646 char* SoccerTypes::getViewAngleStr( ViewAngleT va )
01647 {
01648   switch( va )
01649   {
01650     case VA_NARROW:  return "narrow";
01651     case VA_NORMAL:  return "normal";
01652     case VA_WIDE:    return "wide";
01653     case VA_ILLEGAL:
01654     default:         return NULL;
01655   }
01656 }
01657 
01661 ViewAngleT SoccerTypes::getViewAngleFromStr( char* str )
01662 {
01663   switch( str[1] )
01664   {
01665     case 'a': return VA_NARROW;
01666     case 'o': return VA_NORMAL;
01667     case 'i': return VA_WIDE;
01668     default:  return VA_ILLEGAL;
01669   }
01670 }
01671 
01679 AngDeg SoccerTypes::getHalfViewAngleValue( ViewAngleT va )
01680 {
01681   switch( va )
01682   {
01683     case VA_NARROW:  return 22.5;
01684     case VA_NORMAL:  return 45.0;
01685     case VA_WIDE:    return 90.0;
01686     case VA_ILLEGAL:
01687     default:         return 0.0;
01688   }
01689 
01690 }
01691 
01696 char* SoccerTypes::getViewQualityStr( ViewQualityT vq )
01697 {
01698   switch( vq )
01699   {
01700     case VQ_HIGH:    return "high";
01701     case VQ_LOW:     return "low";
01702     case VQ_ILLEGAL:
01703     default:         return NULL;
01704   }
01705 }
01706 
01711 ViewQualityT SoccerTypes::getViewQualityFromStr( char* str )
01712 {
01713     if( str[0] == 'h' )      return VQ_HIGH;
01714     else if( str[0] == 'l' ) return VQ_LOW;
01715     else                     return VQ_ILLEGAL;
01716 }
01717 
01722 char* SoccerTypes::getCommandStr( CommandT com )
01723 {
01724   switch( com )
01725   {
01726     case CMD_DASH:        return "dash";
01727     case CMD_TURN:        return "turn";
01728     case CMD_TURNNECK:    return "turn_neck";
01729     case CMD_CHANGEVIEW:  return "change_view";
01730     case CMD_CATCH:       return "catch";
01731     case CMD_KICK:        return "kick";
01732     case CMD_MOVE:        return "move";
01733     case CMD_SENSEBODY:   return "sense_body";
01734     case CMD_SAY:         return "neck";
01735     case CMD_ILLEGAL:
01736     default:               return NULL;
01737 
01738   }
01739 }
01740 
01746 bool SoccerTypes::isPrimaryCommand( CommandT com )
01747 {
01748   return com == CMD_KICK || com == CMD_DASH || com == CMD_MOVE ||
01749          com == CMD_TURN || com == CMD_CATCH ;
01750 }
01751 
01752 
01757 char* SoccerTypes::getSideStr( SideT s )
01758 {
01759   switch( s )
01760   {
01761     case SIDE_LEFT:    return "l";
01762     case SIDE_RIGHT:   return "r";
01763     case SIDE_ILLEGAL:
01764     default:           return NULL;
01765   }
01766 }
01767 
01772 SideT SoccerTypes::getSideFromStr( char* str )
01773 {
01774   if( str[0] == 'l' )      return SIDE_LEFT;
01775   else if( str[0] == 'r' ) return SIDE_RIGHT;
01776   else                     return SIDE_ILLEGAL;
01777 
01778 }
01779 
01785 char* SoccerTypes::getBallStatusStr( BallStatusT bs )
01786 {
01787   switch( bs )
01788   {
01789     case BS_IN_FIELD:      return "in_field";
01790     case BS_GOAL_LEFT:     return "goal_left";
01791     case BS_GOAL_RIGHT:    return "goal_right";
01792     case BS_OUT_OF_FIELD:  return "out_of_field";
01793     default:               return NULL;
01794   }
01795 }
01796 
01801 BallStatusT SoccerTypes::getBallStatusFromStr( char* str )
01802 {
01803   switch( str[0] )
01804   {
01805     case 'i': return BS_IN_FIELD;
01806     case 'o': return BS_OUT_OF_FIELD;
01807     case 'g': return (str[5]=='l') ? BS_GOAL_LEFT : BS_GOAL_RIGHT;
01808     default:
01809               cout << "(SoccerTypes::getBallStatusFromStr) illegal status " <<
01810                       str << endl;
01811               return BS_ILLEGAL;
01812   }
01813 }
01814 
01815 
01816 /******************************************************************************/
01817 /********************** TESTING PURPOSES **************************************/
01818 /******************************************************************************/
01819 
01820 /*
01821 int main( void )
01822 {
01823   char* s = "(p \"1\" 3)";
01824 
01825       "(see 0 ((g r) 56.3 0) ((f c) 3.8 0 -0 0) ((f r t) 66 -31) ((f r b)
01826       66 31) ((f p r t) 44.7 -26) ((f p r c) 39.6 0) ((f p r
01827       b) 44.7 26) ((f g r t) 56.8 -7) ((f g r b) 56.8 7) ((f t
01828       r 40) 58.6 -41) ((f t r 50) 66.7 -35) ((f b r 40) 58.6
01829       41) ((f b r 50) 66.7 35) ((f r t 30) 68 -26) ((f r t 20)
01830       64.7 -18) ((f r t 10) 62.2 -9) ((f r 0) 61.6 0) ((f r b
01831       10) 62.2 9) ((f r b 20) 64.7 18) ((f r b 30) 68 26) ((b)
01832       3.7 0 0 0) ((P) 1.2 179) ((P) 0.6 179) ((p "1" 3) nan 0
01833       0 0 0 0) ((p "1" 4) nan 0 0 0 0 0) ((l r) 56.3 -89))";
01834   char *ptr = s;
01835   char buf[1023];
01836   printf("%s\n", ptr );
01837   ObjectT o = SoccerTypes::getObjectFromStr(&ptr, "1");
01838   printf("%d, %s\n", o, SoccerTypes::getObjectStr(buf,o,"1") );
01839 }
01840 
01841 
01842 int main( void )
01843 {
01844   Time t( 10, 0 );
01845   t.show();
01846   t.updateTime( 10 );
01847   t.show();
01848   t.updateTime( 10 );
01849   t.show();
01850   cout << t.isStopped();
01851   t.updateTime( 12 );
01852   t.show();
01853   t.updateTime( 12);
01854   t.setTimeStopped(2);
01855   Time t2( 12, 3 );
01856   cout << t.getTimeDifference( t2 ) << " " << t2.isStopped() << endl;
01857   cout << (t < t2 ) << ( t > t2 ) << ( t <= t2 ) << (t == t2 ) << endl;
01858 }
01859 
01860 */

Generated on Thu Mar 7 00:37:43 2002 for UvA Trilearn 2001 by doxygen1.2.12 written by Dimitri van Heesch, © 1997-2001