field.c

在LINUX下运行的仿真机器人服务器源代码

				std::cerr << "Warning:Illegal team name." << std::endl 
             << "   message = " << init_message << std::endl ;
			return NULL ;
		}
	}
		
  if (!sscanf(ptr, "%f", &version)) {
		if (ServerParam::instance().verbose)
			std::cerr << "Warning:Illegal initialize message." << std::endl 
           << "   message = " << init_message << std::endl ;
		return NULL ;
	}
  while (*ptr != (char)NULL) {
    if (isdigit(*ptr) || *ptr == '.' || isspace(*ptr))
      ptr++ ;
    else
      break ;
	}

  if (*ptr++ != ')') {
		if (ServerParam::instance().verbose)
			std::cerr << "Warning:Illegal initialize message." << std::endl 
           << "   message = " << init_message << std::endl ;
		return NULL ;
	}
  
  while (*ptr != (char)NULL) {
    if (isspace(*ptr))
      ptr++ ;
    else
      break ;
	}
  
  if (*ptr == ')') {
		return newPlayer(teamname, (Value)version, goalie_flag, addr ) ;
	}
  
  if (strncmp(ptr, "(goalie)", 8)) {
		if (ServerParam::instance().verbose)
			std::cerr << "Warning:Illegal initialize message." << std::endl 
           << "   message = " << init_message << std::endl ;
		return NULL ;
	}

  goalie_flag = TRUE ;
	return newPlayer(teamname, (Value)version, goalie_flag, addr ) ;
}

OnlineCoach* Stadium::newCoach( const rcss::net::Addr& addr,
                                const char* init_message )
{
		const int buflen = 1024;
		const Value default_olcoach_version = 5.0;

		char teamname[buflen] ;
		double version = default_olcoach_version;

	// int goalie_flag = FALSE ;
	// int count = 0 ;
        char coachname[buflen];

	int count_params = sscanf(init_message, 
                              "(init %[^ ()] %[^ ()])", 
                              teamname,
                              coachname);

    

	switch (count_params) 
    {
        case 0:			// was not able to read in even team name
            if (ServerParam::instance().verbose)
                std::cerr << "Warning:Illegal initialize message." << std::endl 
                          << "   message = " << init_message << std::endl ;
            return NULL ;
            break;		// just for safety - 'return' code above might change
        case 1:
            // no coach name was sent so set it to null
            coachname[ 0 ] = 0;
	        break;
        case 2:
            // teamname and coachname where sent.
            break;
        default:
            // we should *never* reach this branch
            std::cerr << "Warning: Internal error at " 
                      << __FILE__ << ":" << __LINE__ << std::endl;
            return NULL;
    }

    const char* ver_msg = init_message;
    do
    {
        ++ver_msg;
    }
    while( *ver_msg != 0 && *ver_msg != '(' );
    if( ver_msg != 0 )
    {
        count_params = sscanf(ver_msg, 
                              "(version %lf))", 
                              &version);
        if (version < 5.00) 
        {
            if (ServerParam::instance().verbose)
                std::cerr << "Warning: No online coach for versions less than than 5.00" << std::endl;
            return NULL;
        }
    }

	if (strlen(teamname) > 32) 
    {
      if (ServerParam::instance().verbose)
        std::cerr << "Warning:Too long team name." << std::endl
             << "   message = " << init_message << std::endl ;
      return NULL ;
    }

//      if (strncmp(ptr, "(init ", 6)) {
//  		if (ServerParam::instance().verbose)
//  			std::cerr << "Warning:Illegal initialize message." << std::endl 
//  					<< "   message = " << init_message << std::endl ;
//  		return NULL ;
//  	}
//      ptr += 6 ;

  OnlineCoach* olc = NULL;
  if (team_l->name != NULLCHAR && !strcmp(team_l->name, teamname)) 
    {
      olc = team_l->olcoach;
      olc->side = LEFT;
    }
  else if (team_r->name != NULLCHAR && !strcmp(team_r->name, teamname)) 
    {
      olc = team_r->olcoach; 
      olc->side = RIGHT;
    }
  else
    return NULL;

  if(olc->assignedp == TRUE) 
    {
      return NULL ;
    }

  
  if( !olc->connect( addr ) )
  {
      return NULL;
  }

  bool found = true;

    olc->version = version;					

    rcss::SerializerOnlineCoach::Creator creator;
    
    if( rcss::SerializerOnlineCoach::factory().getCreator( creator,
							   (int)olc->version ) )
    {
	const rcss::SerializerOnlineCoach* ser = creator();
	if( ser )
	{

	
	    olc->setSerializer( *ser );
	    
	    rcss::AudioSenderOnlineCoach::Params audio_params( *this,
							       olc->getTransport(),
							       *olc,
							       *ser );
	    
	    rcss::AudioSenderOnlineCoach::Creator audio_cre;
	    if( rcss::AudioSenderOnlineCoach::factory().getCreator( audio_cre,
								    (int)olc->version ) )
	    {
		olc->setAudioSender( audio_cre( audio_params ) );
		
		rcss::InitSenderOnlineCoach::Params init_params( olc->getTransport(),
								 *olc,
								 *this,
								 *ser );
		
		rcss::InitSenderOnlineCoach::Creator init_cre;
		if( rcss::InitSenderOnlineCoach::factory().getCreator( init_cre,
								       (int)olc->version ) )
		{
		    rcss::InitSenderOnlineCoach::Ptr isoc 
			= init_cre( init_params ); 
		    olc->rcss::InitObserver<rcss::InitSenderOnlineCoach>::setInitSender( isoc );      
		}
		else
		{
		    found = false;
		}
	    }
	    else
	    {
		found = false;
	    }
	}
	else
	{
	    found = false;
	}
    }
    else
    {
	found = false;
    }

    if( !found )
    {
	cerr << "Error: Could not find serializer or sender for version " 
	     << (int)olc->version << endl;
	return NULL;
    } 

  olc->assignedp = TRUE ;
				
  olc->setEnforceDedicatedPort ( version >= 8.0 );

  M_listeners.push_back( olc );
      
  M_remote_online_coaches.push_back( olc );


  olc->rcss::InitObserver<rcss::InitSenderOnlineCoach>::sendInit();

//    if (olc->version >= 6.00)
//      {
//        if ( olc->side == LEFT )
//          olc->send("(init l ok)");
//        else
//          olc->send("(init r ok)");
//      }
//    else
//      olc->send("(init ok)") ;

  olc->rcss::InitObserver<rcss::InitSenderOnlineCoach>::sendServerParams();
  olc->rcss::InitObserver<rcss::InitSenderOnlineCoach>::sendPlayerParams();
  olc->rcss::InitObserver<rcss::InitSenderOnlineCoach>::sendPlayerTypes();
  olc->rcss::InitObserver<rcss::InitSenderOnlineCoach>::sendChangedPlayers();
					
//    if ( olc->version >= 7.00 )
//      {
//        send_parameter_info ( olc );
//        send_changed_players ( olc );
//      }

  if( olc->version >= 8.0 )
    {
      olc->sendPlayerClangVer();
    }
      
  olc->setName( coachname );
  
  return olc ;
}

Player* Stadium::reconnectClient( const rcss::net::Addr& addr,
                                  const char* reconnect_message)
{
	char buffer[128] ;
	int r ;
	ID rnum ;

	r = sscanf(reconnect_message,"(reconnect %s %d)", buffer, &rnum) ;

	if(r < 2) {
		if (ServerParam::instance().verbose)
			std::cerr << "Warning:Illegal initialize message." << std::endl 
					<< "   message = " << reconnect_message << std::endl ;
		return NULL ;
	}

	for( r = 0 ; r < MAX_PLAYER * 2; r++ )
		if( player[r]->team->enable )
			if( !strcmp( player[r]->team->name, buffer )
          && player[r]->unum == rnum )
        break ;

	/* It's same. */
	if( r < MAX_PLAYER * 2 ) 
	{
	    if( player[r]->open() != 0 )
		return NULL;
	    if( !player[r]->connect( addr ) )
		return NULL;
	    if( !player[r]->setSenders() )
		return NULL;
	    addListener( player[r] );
	    
//          std::cerr << "Found player" << std::endl;

      player[r]->setEnforceDedicatedPort ( player[r]->version >= 8.0 );
      M_remote_players.push_back ( player[r] );
      player[r]->alive = STAND ;
      player[r]->enable = TRUE ;
      if (player[r]->goalie)
        player[r]->alive |= GOALIE ;
      return player[r] ;
    }
	else
		return NULL ;
}

void Stadium::byeClient(Player* bye)
{
	if( bye->goalie == TRUE && M_caught_ball == bye )
		M_caught_ball = NULL;
	bye->enable = FALSE ;
//  	bye->client.host = 0 ;
//  	bye->client.port = -1 ;

	bye->alive = DISABLE ;
	bye->pos.x = -(bye->unum * 3 * bye->team->side) ;
	bye->pos.y = -PITCH_WIDTH/2.0 - 3.0 ;
}

void Stadium::step()
{
	int i ;

	for (i = 0; i < 2; i++) {
	  if (olcoach[i]) {
	    olcoach[i]->check_message_queue(time);
	    olcoach[i]->update_messages_left(time);
	  }
	}

  for ( PlayerCont::iterator i = M_remote_players.begin ();
        i != M_remote_players.end (); ++i )
    {
      (*i)->getArm ().incAge ();
    }

  // the following clears the flags which are used to tell if both
  // teams touched the ball during a cycle.  It's used for back passes9
  clearTeamTouches();

	if (mode == PM_BeforeKickOff)
    {
      motable._turn();
      if (ServerParam::instance().kickoffoffside == TRUE)
        check_players_move() ;
      for_each( M_referees.begin(), M_referees.end(), &Referee::doAnalyse );
    }
	else if (mode == PM_AfterGoal_Right)
    {
      M_caught_ball = NULL;
      motable._inc ( mode ) ;
      if (++after_g_time > AFTER_GOAL_WAIT)
        {
          placeBall( PM_KickOff_Left, LEFT, PVector(0.0,0.0) );
          set_players() ;
        }
      for_each( M_referees.begin(), M_referees.end(), &Referee::doAnalyse );
    }
	else if (mode == PM_AfterGoal_Left) {
		M_caught_ball = NULL;
		motable._inc ( mode ) ; 
		if (++after_g_time > AFTER_GOAL_WAIT) 
      {
        placeBall( PM_KickOff_Right, RIGHT, PVector(0.0,0.0) );
        set_players() ;
      }
    for_each( M_referees.begin(), M_referees.end(), &Referee::doAnalyse );
	}
	else if (mode == PM_OffSide_Right) {
		M_caught_ball = NULL;
		motable._inc ( mode ) ;
    clearPlayersFromBall( RIGHT );
		check_player_after_offside() ;
		if (++after_offside_time > AFTER_OFFSIDE_WAIT) {
			change_play_mode(PM_FreeKick_Left) ;
		}
    for_each( M_referees.begin(), M_referees.end(), &Referee::doAnalyse );
	}
	else if (mode == PM_OffSide_Left) {
		M_caught_ball = NULL;
		motable._inc ( mode ) ; 
    clearPlayersFromBall( LEFT );
		check_player_after_offside() ;
		if (++after_offside_time > AFTER_OFFSIDE_WAIT) {
			change_play_mode(PM_FreeKick_Right) ;
		}
    for_each( M_referees.begin(), M_referees.end(), &Referee::doAnalyse );
	}
	else if( mode == PM_Back_Pass_Right )
    {
      M_caught_ball = NULL;
      motable._inc ( mode ); 
      clearPlayersFromBall( RIGHT );
      if( ++after_back_pass_time > AFTER_BACKPASS_WAIT )
        change_play_mode(PM_FreeKick_Left) ;
      for_each( M_referees.begin(), M_referees.end(), &Referee::doAnalyse );
    }
	else if( mode == PM_Back_Pass_Left) {
		M_caught_ball = NULL;
		motable._inc ( mode ); 
    clearPlayersFromBall( LEFT );
		if (++after_back_pass_time > AFTER_BACKPASS_WAIT) {
			change_play_mode(PM_FreeKick_Right) ;
		}
    for_each( M_referees.begin(), M_referees.end(), &Referee::doAnalyse );
	}
	else if (mode == PM_Free_Kick_Fault_Right) {
		M_caught_ball = NULL;
		motable._inc ( mode ) ; 
    clearPlayersFromBall( RIGHT );
		if (++M_after_free_kick_fault_time > AFTER_FREE_KICK_FAULT_WAIT) {
			change_play_mode(PM_FreeKick_Left) ;
		}
    for_each( M_referees.begin(), M_referees.end(), &Referee::doAnalyse );
	}
	else if (mode == PM_Free_Kick_Fault_Left) {
		M_caught_ball = NULL;
		motable._inc ( mode );
    clearPlayersFromBall( LEFT );
		if (++M_after_free_kick_fault_time > AFTER_FREE_KICK_FAULT_WAIT) {
			change_play_mode(PM_FreeKick_Right) ;
		}
    for_each( M_referees.begin(), M_referees.end(), &Referee::doAnalyse );
	}
    else if( mode == PM_CatchFault_Left )
    {
        M_caught_ball = NULL;
        motable._inc( mode );
        clearPlayersFromBall( LEFT );
        if( ++m_after_catch_fault_time > AFTER_CATCH_FAULT_WAIT )
        {
            change_play_mode(PM_IndFreeKick_Right) ;
        }
        for_each( M_referees.begin(), M_referees.end(), &Referee::doAnalyse );
    }
    else if( mode == PM_CatchFault_Right )
    {
        M_caught_ball = NULL;
        motable._inc( mode );
        clearPlayersFromBall( RIGHT );
        if( ++m_after_catch_fault_time > AFTER_CATCH_FAULT_WAIT )
        {
            change_play_mode(PM_IndFreeKick_Left) ;