ProgrammierMethodik 2002 - RoboCup

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

RCWorld.java

Go to the documentation of this file.
00001 /*
00002  * $Id: RCWorld_8java-source.html,v 1.2 2002/07/07 20:59:52 stork Exp $
00003  *
00004  * $Log: RCWorld_8java-source.html,v $
00004  * Revision 1.2  2002/07/07 20:59:52  stork
00004  * update dokumenation
00004  *
00005  * Revision 1.24  2002/07/05 18:34:08  stork
00006  * update dokumentation
00007  *
00008  * Revision 1.23  2002/07/04 16:25:48  stork
00009  * reactivate log comments 2
00010  *
00011  * Revision 1.22  2002/07/04 16:19:13  stork
00012  * reactivate log comments
00013  *
00014  * Revision 1.20  2002/07/04 12:51:53  stork
00015  * add new data
00016  *
00017  * Revision 1.19  2002/07/04 12:47:41  stork
00018  * add new data
00019  *
00020  * Revision 1.18  2002/07/03 19:01:06  stork
00021  * cleanup
00022  *
00023  * Revision 1.17  2002/07/03 17:24:37  stork
00024  * add some debug Messages
00025  *
00026  * Revision 1.15  2002/07/02 20:52:26  stork
00027  * +invert NewData
00028  * +RCLog update
00029  *
00030  * Revision 1.14  2002/06/27 20:26:40  stork
00031  * add + update dokumentation
00032  *
00033  * Revision 1.13  2002/06/23 21:09:09  stork
00034  * add support for OutOfField behavior of the player
00035  *
00036  * Revision 1.12  2002/06/22 20:14:27  stork
00037  * add MessagFilter for getting the right playmode
00038  * add some more dokumentation
00039  *
00040  * Revision 1.11  2002/06/21 19:46:08  stork
00041  * add support for asnc. event handling
00042  *
00043  * Revision 1.10  2002/06/10 20:53:14  stork
00044  * + add calculation of enemies and friend
00045  * + only update when there was a sence event
00046  *
00047  * Revision 1.9  2002/06/08 15:26:51  stork
00048  * tipfehler
00049  *
00050  * Revision 1.8  2002/06/08 15:16:05  stork
00051  * activate brain
00052  *
00053  * Revision 1.7  2002/06/08 14:42:07  stork
00054  * first version that maybe will work
00055  *
00056  * Revision 1.6  2002/06/07 21:35:19  stork
00057  * maybe working for the left side
00058  *
00059  * Revision 1.5  2002/06/07 18:15:45  stork
00060  * add basic calculation stuff
00061  *
00062  * Revision 1.3  2002/05/29 15:18:40  stork
00063  * update interface and some event hanling methods
00064  *
00065  * Revision 1.2  2002/05/21 20:57:14  stork
00066  * first communicator version
00067  *
00068  * Revision 1.1.1.1  2002/05/21 20:32:06  stork
00069  * empty project
00070  *
00071  */
00072 import java.util.*;
00073 import java.awt.*;
00074 import java.awt.geom.*;
00075 import java.math.*;
00076 
00077 
00083 public class RCWorld  
00084     implements RCPlayMode, RCView, RCType, RCSender, RCEventType {
00086     public RCObject Ball;       // the ball
00087     public RCObject[] Enemies;  // the enemies
00088     public RCObject[] Friends;
00089     public RCEvent Event;
00090     public boolean NewEvent;
00091     public int PlayerNumber;    
00092 
00093     // defines the quad. of the player
00094     public double X1;
00095     public double Y1;
00096     public double X2;
00097     public double Y2;
00098     
00099     public double angle; // abs angle of the player
00100     public double AngleToBall;        // contains the relative angle from angle(RCWorld) to the ball
00101     public int AngleToBallTimeStamp;  // timestamp of the value in AngleToBall
00102     public boolean NewData;           // true if every
00103 
00104     public final String MsgStart = "RCTEAM:"; // prefix for our messages 
00105 
00106     public int GameMode;  //  current game mode
00107 
00108     public int Side;    // our side
00109 
00110     public RCServerParamEvent ServerParam;
00111     public RCPlayerParamEvent PlayerParam;
00112     public RCPlayerTypeEvent PlayerType[];
00113     public RCSenceEvent SenceBody;
00114 
00115     /* little helpers for calculation */
00116     public RCSeeEvent NearestFlag = null;
00117     public RCSeeEvent NearestLine = null;
00118     public boolean ValidPosition = false;
00119 
00120     public int CurrentTimeStamp; // the 
00121 
00122     /* depreciated helpers for the handling position out of the field */
00123     boolean OutOfField;
00124     int OutOfFieldCounter;
00125     boolean enableOutOfField;
00126     Point2D.Double OldPosition;
00127 
00129     private RCDisplay Display;
00130     private RCBrain Brain;
00131     public RCLog Log;
00132     
00136     public RCWorld ( RCLog Log ){
00137         /* init */
00138         CurrentTimeStamp = -1;
00139         Friends = new RCObject[11];
00140         Enemies = new RCObject[11];
00141         Ball = new RCObject();
00142         PlayerType = new RCPlayerTypeEvent[8];
00143         Brain = null;
00144         Display = null;
00145         this.Log = Log;
00146         OutOfField = false;
00147         enableOutOfField = false;
00148         OldPosition = new Point2D.Double();
00149         OldPosition.x = 0;
00150         OldPosition.y = 0;
00151 
00152         // create objects
00153         for( int x = 0; x < 11 ; x++){
00154             Friends[x] = new RCObject();
00155             Enemies[x] = new RCObject();
00156         }       
00157     }
00158 
00159     
00165     public void setBrain( RCBrain Brain ){
00166         this.Brain = Brain;
00167     }
00168 
00169     
00175     public void setDisplay( RCDisplay Display ){
00176         this.Display = Display;
00177     }
00178 
00185     public synchronized void receiveEvent ( LinkedList Events ){
00186         NearestFlag = null;
00187         NearestLine = null;
00188         ValidPosition = false;
00189         boolean update = false;
00190         OutOfFieldCounter = 0;
00191 
00192         Log.Log("Player-"+PlayerNumber+" : CurrentTimeStamp "+CurrentTimeStamp);
00193 
00194         /* process the event list */
00195         try{
00196             ListIterator it = Events.listIterator(0);
00197             while( it.hasNext() ){
00198                 RCEvent event = (RCEvent)it.next();
00199                 it.remove();
00200                 switch( event.Type ){
00201                 case SERVER_PARAM:
00202                     {
00203                         /* backup the ServerParamEvent */
00204                         Log.Log("Player-"+PlayerNumber+" : work on ServerParamMessage");
00205                         this.ServerParam = (RCServerParamEvent)event;
00206                         break;
00207                     }
00208                 case PLAYER_PARAM:
00209                     {
00210                         /* backup the PlayerParamEvent */
00211                         Log.Log("Player-"+PlayerNumber+" : work on PlayerParam-Message");
00212                         this.PlayerParam = (RCPlayerParamEvent)event;
00213                         break;
00214                     }
00215                 case PLAYER_TYPE:
00216                     {
00217                         /* backup the PlayerTypeEvent */
00218                         Log.Log("Player-"+PlayerNumber+" : work on PlayerType-Message");
00219                         RCPlayerTypeEvent PlayerTypeEvent = (RCPlayerTypeEvent)event;
00220                         this.PlayerType[PlayerTypeEvent.id] = PlayerTypeEvent;
00221                         break;
00222                     }
00223                 case HEAR:
00224                     {
00225                         /* parse the HearMessage */
00226                         Log.Log("Player-"+PlayerNumber+" : work on Hear-Message");
00227                         this.MessageFilter((RCHearEvent)event);
00228                         break;   
00229                     }
00230                 case SENCE:
00231                     {
00232                         /* backup SenceBodyEvent */
00233                         Log.Log("Player-"+PlayerNumber+" : work on SenceBody-Message");
00234                         this.SenceBody = (RCSenceEvent)event;
00235                         update = true;
00236                         break;
00237                     }
00238                 case SEE:
00239                     {                  
00240                         Log.Log("Player-"+PlayerNumber+" : work on See-Message");
00241                         CurrentTimeStamp = ((RCSeeEvent)event).TimeStamp;
00242                         NewData = true; // we got freshmeat
00243                         //update = true;
00244                         
00245                         // find nearest line + flag
00246                         if( (ValidPosition == false ) &&
00247                             ((((RCSeeEvent)event).Object == FLAGS ) ||
00248                              (((RCSeeEvent)event).Object == GOAL )  ||
00249                              (((RCSeeEvent)event).Object == LINE )) ){
00250                             
00251                             if( (((RCSeeEvent)event).Object == FLAGS) ||
00252                                 (((RCSeeEvent)event).Object == GOAL )){
00253                                 // flags
00254                                 if( NearestFlag == null ){
00255                                     NearestFlag = (RCSeeEvent)event;
00256                                     break;
00257                                 }else{
00258                                     if( NearestFlag.Distance >= (((RCSeeEvent)event).Distance) ){
00259                                         NearestFlag = (RCSeeEvent)event;
00260                                         break;
00261                                     }
00262                                 }
00263                             }else if( ((RCSeeEvent)event).Object == LINE ){ // LINE
00264                                 // line
00265                                 if( NearestLine == null ){
00266                                     NearestLine = (RCSeeEvent)event;
00267                                     break;
00268                                 }else{
00269                                     if( NearestLine.Distance >= (((RCSeeEvent)event).Distance) ){
00270                                         NearestLine = (RCSeeEvent)event;
00271                                         break;
00272                                     }
00273                                 }
00274                             }
00275                             break;                          
00276                         }
00277                         
00278                         // calculate our position
00279                         if( ValidPosition == false ){
00280                             calculatePosition();
00281                         }
00282                         
00283 
00284                         double AbsAngle = 0;
00285                         double d = 0;
00286                         
00287                         // process the other events
00288                         switch( ((RCSeeEvent)event).Object ){                    
00289                         case BALL:
00290                             AbsAngle = ((angle + ((RCSeeEvent)event).Direction)/180)*Math.PI;
00291                             d = ((RCSeeEvent)event).Distance;
00292                             Ball.insertTime(((RCSeeEvent)event).TimeStamp );
00293                             Ball.insertX(getOurself().X(0) + d*Math.cos(AbsAngle));
00294                             Ball.insertY(getOurself().Y(0) + d*Math.sin(AbsAngle));     
00295                             AngleToBall =  ((RCSeeEvent)event).Direction;
00296                             AngleToBallTimeStamp = ((RCSeeEvent)event).TimeStamp;
00297                             break;
00298                         case ENEMY:
00299                             if( (((RCSeeEvent)event).UniformNumber > 0) &&
00300                                 (((RCSeeEvent)event).UniformNumber <= 11)){
00301                                 int Number = ((RCSeeEvent)event).UniformNumber;
00302                                 AbsAngle = ((angle + ((RCSeeEvent)event).Direction)/180)*Math.PI;
00303                                 d = ((RCSeeEvent)event).Distance;
00304                                 Enemies[Number-1].insertTime(((RCSeeEvent)event).TimeStamp );
00305                                 Enemies[Number-1].insertX(getOurself().X(0) + d*Math.cos(AbsAngle));
00306                                 Enemies[Number-1].insertY(getOurself().Y(0) + d*Math.sin(AbsAngle));    
00307                             }
00308                             break;
00309                         case FRIEND:
00310                             if( (((RCSeeEvent)event).UniformNumber > 0) &&
00311                                 (((RCSeeEvent)event).UniformNumber <= 11)){
00312                                 int Number = ((RCSeeEvent)event).UniformNumber;
00313                                 AbsAngle = ((angle + ((RCSeeEvent)event).Direction)/180)*Math.PI;
00314                                 d = ((RCSeeEvent)event).Distance;
00315                                 Friends[Number-1].insertTime(((RCSeeEvent)event).TimeStamp );
00316                                 Friends[Number-1].insertX(getOurself().X(0) + d*Math.cos(AbsAngle));
00317                                 Friends[Number-1].insertY(getOurself().Y(0) + d*Math.sin(AbsAngle));    
00318                             }
00319                             break;
00320                         }
00321                         
00322                         break;
00323                     }
00324                 }               
00325             }
00326 
00327 
00328             // no objects out there
00329             if( ValidPosition == false )
00330                 calculatePosition();
00331 
00332             // update only when there was an sence event
00333             if( update == true ){
00334         
00335                 // lets think a little bit
00336                 if( (Brain != null) ){
00337                     int x = 0;
00338                     Log.Log("Player-"+PlayerNumber+" : enter brain");
00339                     //NewData = !NewData;
00340                     x = Brain.update(); 
00341                     //NewData = !NewData;
00342                     Log.Log("Player-"+PlayerNumber+" : brain return "+x);
00343                     Log.Log("Player-"+PlayerNumber+" : leave brain");
00344                     NewData = false;  // donīt use the old data in the second call
00345                 }
00346 
00347                 /* update display */
00348                 if( (Display != null) && (getOurself().Time(0)%10 == 0)){
00349                     Display.update();
00350                 }
00351 
00352 
00353                 //Log.Log("Angele = " + angle +" / "+AngleToBall);
00354         
00355             }
00356    
00357         }catch(IndexOutOfBoundsException e){
00358             // shit happens
00359             Log.Debug("Error pos "+e);
00360             //e.printStackTrace();
00361             return;
00362         }
00363     }
00364 
00365 
00366     /* 
00367      * This function calculate the position of our player.
00368      */
00369     public void calculatePosition(){
00370         double x = 0;
00371         double y = 0;
00372         if( (NearestLine == null) || (NearestFlag == null) ){
00373             return; // leave 
00374         }else{
00375                                 // calculate abs angle 
00376             if( Side == LEFT){
00377                 // calculation for left side
00378                                     
00379                 //calculate abs angle
00380                 switch(NearestLine.FirstLocation){
00381                 case TOP:
00382                     /* calculation for top line */
00383                     if( NearestLine.Direction > 0 )
00384                         angle = -1*NearestLine.Direction;
00385                     else
00386                         angle =  -90 - (90+ NearestLine.Direction);
00387                     if( OutOfField == true )
00388                         angle += 180;
00389                     break;
00390                 case LEFT:
00391                     /* calculation for left line */
00392                     if(NearestLine.Direction < 0){
00393                         angle = 180  - (90+NearestLine.Direction);
00394                         if( OutOfField == true )
00395                             angle += 180;
00396                     }else{
00397                         angle = -90 -NearestLine.Direction;
00398                         if( OutOfField == true )
00399                             angle -= 180;
00400                     }
00401                     break;
00402                 case RIGHT:
00403                     /* calculation for right line */
00404                     if( NearestLine.Direction < 0 ){
00405                         angle = -1*(90+NearestLine.Direction);
00406                         if( OutOfField == true )
00407                             angle -= 180;
00408                     }else{
00409                         angle = 90 - NearestLine.Direction;
00410                         if( OutOfField == true )
00411                             angle += 180;
00412                     }
00413                     break;
00414                 case BOTTOM:
00415                     /* calculation for bottom line */
00416                     if( NearestLine.Direction > 0 )
00417                         angle = 180 - NearestLine.Direction;
00418                     else
00419                         angle = -1 * NearestLine.Direction;
00420                     if( OutOfField == true )
00421                         angle -= 180;
00422                     break;
00423                 }
00424             }else{
00425                 // calculation for left side2
00426                                     
00427                 //calculate abs angle 
00428                 switch(NearestLine.FirstLocation){
00429                 case TOP:
00430                     /* calculation for top line */
00431                     if( NearestLine.Direction < 0){
00432                         angle = -1* NearestLine.Direction;
00433                     }else{
00434                         angle = 180 - NearestLine.Direction;
00435                     }
00436                     if( OutOfField == true )
00437                         angle -= 180;
00438                     break;
00439                 case LEFT:
00440                     /* calculation for left line */
00441                     if( NearestLine.Direction < 0){
00442                         angle = -1*(90 + NearestLine.Direction) ;
00443                         if( OutOfField == true )
00444                             angle -= 180;
00445                     }else{
00446                         angle = 90-NearestLine.Direction;
00447                         if( OutOfField == true )
00448                             angle += 180;
00449                     }
00450                     break;
00451                 case RIGHT:
00452                     /* calculation for right line */
00453                     if( NearestLine.Direction < 0){
00454                         angle = 180 - (90+NearestLine.Direction);
00455                         if( OutOfField == true )
00456                             angle += 180;
00457                     }else{
00458                         angle = -90 - NearestLine.Direction; 
00459                         if( OutOfField == true )
00460                             angle -= 180;
00461                     }
00462                     break;
00463                 case BOTTOM:
00464                     /* calculation for bottom line */
00465                     if( NearestLine.Direction < 0){
00466                         angle = -1*(180 + NearestLine.Direction);
00467                     }else{
00468                         angle = -1*NearestLine.Direction;
00469                     }
00470                     if( OutOfField == true )
00471                         angle += 180;
00472                     break;
00473                 }
00474             }
00475 
00476             // check in/out of field
00477 
00478 
00479             // calculate position 
00480             Point2D.Double Flag = getFlag( (RCSeeEvent)NearestFlag );
00481             
00482             if( Side == RIGHT ){
00483                 Flag.x *= -1;
00484                 Flag.y *= -1;
00485             }                           
00486 
00487 //          Log.Log("angle = " + angle );
00488 //          Log.Log("Flag.x = " + Flag.getX() + "   Flag.y = " + Flag.getY());
00489 //          Log.Log("Distance = "+ NearestFlag.Distance );
00490 
00491             // calculate and insert values
00492             double AbsAngle = angle + NearestFlag.Direction;
00493 //          getOurself().insertX(((double)Flag.getX()) - NearestFlag.Distance*Math.cos((AbsAngle/180.0)*Math.PI));
00494 //          getOurself().insertY(((double)Flag.getY()) - NearestFlag.Distance*Math.sin((AbsAngle/180.0)*Math.PI));
00495 //          getOurself().insertTime(NearestLine.TimeStamp);
00496 
00497             x = (((double)Flag.getX()) - NearestFlag.Distance*Math.cos((AbsAngle/180.0)*Math.PI));
00498             y = (((double)Flag.getY()) - NearestFlag.Distance*Math.sin((AbsAngle/180.0)*Math.PI));
00499             getOurself().insertTime(NearestLine.TimeStamp);
00500 
00501 
00502             // check and maybe recalculate
00503             if( (CurrentTimeStamp >= 10) &&
00504                 (enableOutOfField == true) &&
00505                 ((Math.abs( OldPosition.x - x ) > 5) ||(Math.abs( OldPosition.y - y ) > 5))){
00506                 OutOfField = !OutOfField;
00507                 Log.Log("Player "+ PlayerNumber + " : OUT OF FIELD  switch "+ OutOfField);
00508                 
00509                 // check for moving
00510                 if( ++OutOfFieldCounter >= 3 ){
00511                     // calculate new position
00512                     enableOutOfField = false; // deactivate
00513                     calculatePosition();      // recalculate a position in the field
00514                     enableOutOfField = true;  // reactivate
00515                 }else{
00516                     calculatePosition();  // recalculate 
00517                     return;               // return 
00518                 }
00519             }
00520             
00521             // set the values
00522             getOurself().insertX(x);
00523             getOurself().insertY(y);
00524             getOurself().insertTime(NearestLine.TimeStamp);
00525             OldPosition.x = x;
00526             OldPosition.y = y;
00527 
00528 //          Log.Log("("+getOurself().X(0)+"/"+getOurself().Y(0)+")");
00529             
00530                                 
00531             // we got our position 
00532             ValidPosition = true;
00533         }
00534 
00535     }
00536 
00537 
00543     public RCObject getOurself(){
00544         try{
00545             return Friends[PlayerNumber-1];
00546         }catch(IndexOutOfBoundsException e){
00547             return new RCObject();
00548         }
00549     }
00550 
00551 
00559     public Point2D.Double getFlag(RCSeeEvent event){
00560         Point2D.Double Flag = new Point2D.Double(0,0);
00561         
00562         /* we see the goal */
00563         if( event.Object == GOAL ){
00564             Flag.y = 0;
00565             if( event.FirstLocation == LEFT )
00566                 Flag.x = -52.5;
00567             else
00568                 Flag.x = 52.5;
00569             
00570             return Flag;
00571         }
00572 
00573         switch( event.FirstLocation ){
00574         case TOP:
00575             Flag.y = -39;
00576             switch( event.SecondLocation ){
00577             case LEFT:
00578                 Flag.x = -1*event.Number;
00579                 break;
00580             case CENTER:
00581                 Flag.x = 0;
00582                 break;
00583             case RIGHT:
00584                 Flag.x = event.Number;
00585                 break;
00586             }
00587             return Flag;
00588         case RIGHT:
00589             Flag.x = 57.5;
00590             switch( event.SecondLocation ){
00591             case TOP:
00592                 if( event.Number < 0 ){
00593                     Flag.x = 52.5;
00594                     Flag.y = -34;
00595                 }else{
00596                     Flag.y = -1*event.Number;
00597                 }
00598                 break;
00599             case CENTER:
00600                 Flag.y = 0;
00601                 break;
00602             case BOTTOM:
00603                 if( event.Number < 0){
00604                     Flag.x = 52.5 ;
00605                     Flag.y = 34;
00606                 }else{
00607                     Flag.y = event.Number;
00608                 }
00609                 break;
00610             }
00611             return Flag;
00612         case BOTTOM:
00613             Flag.y = 39;
00614             switch( event.SecondLocation ){
00615             case LEFT:
00616                 Flag.x = -1*event.Number;
00617                 break;
00618             case CENTER:
00619                 Flag.x = 0;
00620                 break;
00621             case RIGHT:
00622                 Flag.x = event.Number;
00623                 break;
00624             }
00625             return Flag;
00626         case LEFT:
00627             Flag.x = -57.5;
00628             switch( event.SecondLocation ){
00629             case TOP:
00630                 if( event.Number < 0 ){
00631                     Flag.y = -34;
00632                     Flag.x = -52.5;
00633                 }else{
00634                     Flag.y = -1*event.Number;
00635                 }
00636                 break;
00637             case CENTER:
00638                 Flag.y = 0;
00639                 break;
00640             case BOTTOM:
00641                 if( event.Number < 0 ){
00642                     Flag.y = 34;
00643                     Flag.x = -52.5;
00644                 }else{
00645                     Flag.y = event.Number;
00646                 }
00647                 break;
00648             }
00649             return Flag;
00650         case GOAL:
00651             Flag.x = -52.5;
00652             switch( event.ThirdLocation ){
00653             case TOP:
00654                 Flag.y = -7.01;
00655                 break;
00656             case BOTTOM:
00657                 Flag.y = 7.01;
00658                 break;
00659             case UNDEFINED:
00660                 Flag.y = 0;
00661                 break;
00662             }
00663             
00664             if( event.SecondLocation == RIGHT )
00665                 Flag.x *= -1;
00666 
00667             return Flag;            
00668             //      break;
00669         case LINE:   // (l p  ( line before the goals
00670             switch( event.ThirdLocation ){
00671             case TOP:
00672                 Flag.x = -36;
00673                 Flag.y = -20.175;
00674                 break;
00675             case CENTER:
00676                 Flag.x = -36;
00677                 Flag.y = 0;
00678                 break;
00679             case BOTTOM:
00680                 Flag.x = -36;
00681                 Flag.y = 20.175;
00682                 break;
00683             }
00684             if( event.SecondLocation == RIGHT ){
00685                 Flag.x *= -1;
00686             }
00687             return Flag;
00688         case CENTER:
00689             if( event.SecondLocation == UNDEFINED ){
00690                 // (f c)
00691                 return new Point2D.Double(0, 0);
00692             }else if( event.SecondLocation == TOP ){
00693                 // (f c t)
00694                 return new Point2D.Double(0, -34);
00695             }else{
00696                 // (f c b)
00697                 return new Point2D.Double(0, 34);               
00698             }       
00699         }
00700 
00701         return new Point2D.Double(0,0);
00702     }
00703 
00710     public void MessageFilter(RCHearEvent Event){
00711         if( Event.Message.startsWith( MsgStart ) == true ){
00712             // get our messages
00713             // at the moment we don't use this feature
00714         }else if( Event.Message.startsWith("before") == true ){
00715             GameMode = BEFORE_KICKOFF;
00716         }else if( (Event.Message.compareTo("play_on") == 0) ){
00717             GameMode = PLAY_ON;
00718         }else if( (Event.Message.compareTo("time_over") == 0) ){
00719             GameMode = TIME_OVER;
00720         }else if( (Event.Message.compareTo("kick_off_l") == 0) ){
00721             GameMode = KICKOFF_LEFT;
00722         }else if( (Event.Message.compareTo("kick_off_r") == 0) ){
00723             GameMode = KICKOFF_RIGHT;
00724         }else if( (Event.Message.compareTo("kick_in_l") == 0) ){
00725             GameMode = KICKIN_LEFT;
00726         }else if( (Event.Message.compareTo("kick_in_r") == 0) ){
00727             GameMode = KICKIN_RIGHT;
00728         }else if( (Event.Message.compareTo("free_kick_l") == 0) ){
00729             GameMode = FREEKICK_LEFT;
00730         }else if( (Event.Message.compareTo("free_kick_r") == 0) ){
00731             GameMode = FREEKICK_RIGHT;
00732         }else if( (Event.Message.compareTo("corner_kick_l") == 0) ){
00733             GameMode = CORNERKICK_LEFT;
00734         }else if( (Event.Message.compareTo("corner_kick_r") == 0) ){
00735             GameMode = CORNERKICK_RIGHT;
00736         }else if( (Event.Message.compareTo("goal_kick_l") == 0) ){
00737             GameMode = GOALKICK_LEFT;
00738         }else if( (Event.Message.compareTo("goal_kick_r") == 0) ){
00739             GameMode = GOALKICK_RIGHT;
00740         }else if( Event.Message.startsWith("goal_l") ){
00741             GameMode = KICKOFF_RIGHT;
00742         }else if( Event.Message.startsWith("goal_r") ){
00743             GameMode = KICKOFF_RIGHT;
00744         }else if( (Event.Message.compareTo("offside_l") == 0) ){
00745             GameMode = FREEKICK_RIGHT;
00746         }else if( (Event.Message.compareTo("offside_r") == 0) ){
00747             GameMode = FREEKICK_LEFT;
00748         }else if( (Event.Message.compareTo("drop_ball") == 0) ){
00749             GameMode = PLAY_ON;
00750         }else if( (Event.Message.compareTo("foul_l") == 0) ){
00751             GameMode = FREEKICK_RIGHT;
00752         }else if( (Event.Message.compareTo("foul_r") == 0) ){
00753             GameMode = FREEKICK_LEFT;
00754         }else if( (Event.Message.compareTo("goalie_catch_ball_l") == 0) ){
00755             GameMode = FREEKICK_LEFT;
00756         }else if( (Event.Message.compareTo("goalie_catch_ball_r") == 0) ){
00757             GameMode = FREEKICK_RIGHT;
00758         }else if( Event.Message.startsWith("time_up") ){
00759             GameMode = TIME_OVER;
00760         }else if( (Event.Message.compareTo("half_time") == 0) ){
00761             GameMode = BEFORE_KICKOFF;
00762         }else if( (Event.Message.compareTo("time_extended") == 0) ){
00763             GameMode = BEFORE_KICKOFF;
00764         }
00765     }
00766 }
00767 

(c) Copyright by Gruppe 1 :
  • Frederik Transier
  • Motitz Ritter
  • Oliver Strassburger
  • Sven Stork