object.c

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

      for ( int i = 0; i < n; ++i )
        {
          if ( object [ i ] != NULL )
            {
              object [ i ]->post_col_pos = PVector ( 0, 0 );
              object [ i ]->col_count = 0;
            }
        }
      
      for ( int i = 0; i < n - 1; ++i )
        for ( int j = i + 1; j < n; j++ )
          {
            if ( detectCollision ( object [ i ], object [ j ] ) )
              {
                col = true;
                calcCollPos ( object [ i ], object [ j ], playmode );
              }
          }
      
      for ( int i = 0; i < n; ++i )
        moveToCollPos ( object [ i ] );
      
      max--;
    }
  while ( col && max > 0 );
  
  for ( int i = 0; i < n; ++i )
    updateCollVel ( object [ i ] );
}

bool detectCollision ( MPObject* a, MPObject* b )
{
  if ( a != NULL 
       && b != NULL 
       && a != b 
       && a->enable != FALSE 
       && b->enable != FALSE
       && a->pos.distance ( b->pos ) < a->size + b->size )
    {
      if( a->type == MPO_Ball && b->type == MPO_Player ) 
        {
          Player* player = (Player *)b;
          
          // the player that has caught the ball cannot collide with the ball.
          if( player == player->stadium->M_caught_ball )
            return false;

          player->alive |= BALL_TO_PLAYER | BALL_COLLIDE;
          /* we don't want to set last touch if the goalie has caught
             the ball! */
          if ( !player->stadium->M_caught_ball )
            for_each( player->stadium->M_referees.begin(),
                      player->stadium->M_referees.end(),
                        Referee::doBallTouched( *player ) );
          
          //              player->stadium->last_touch = player;
        }
      else if (a->type == MPO_Player && b->type == MPO_Ball) 
        {
          Player* player = (Player *)a;

          // the player that has caught the ball cannot collide with the ball.
          if( player == player->stadium->M_caught_ball )
            return false;

          player->alive |= BALL_TO_PLAYER | BALL_COLLIDE;
          /* we don't want to set last touch if the goalie has caught
             the ball! */
          if ( !player->stadium->M_caught_ball )
              for_each( player->stadium->M_referees.begin(),
                        player->stadium->M_referees.end(),
                        Referee::doBallTouched( *player ) );
//              player->stadium->last_touch = player;
        }
      else if ( a->type == MPO_Player && b->type == MPO_Player)
        {
          ((Player *)a)->alive |= PLAYER_COLLIDE ;
          ((Player *)b)->alive |= PLAYER_COLLIDE ;
        }
      return true;
    }
  return false;   
}

void calcCollPos ( MPObject* a, MPObject* b, const PlayMode& playmode )
{
  if ( a == NULL || b == NULL )
    return;

  PVector apos;
  PVector bpos;

  if ( playmode != PM_PlayOn  && a->type == MPO_Ball )
    {
      apos = a->pos;
      PVector a2b;
      if ( a->pos == b->pos )
	{
	  Angle b_ang = drand ( -PI, PI );
	  a2b = Polar2PVector ( a->size + b->size, b_ang );
	}
      else
	{
	  a2b = b->pos - a->pos;
	  a2b.r ( a->size + b->size );
	}

      bpos = a->pos + a2b;    
    }
  else if ( playmode != PM_PlayOn && b->type == MPO_Ball )
    {
      bpos = b->pos;
      PVector b2a;
      if ( b->pos == a->pos )
	{
	  Angle a_ang = drand ( -PI, PI );
	  b2a = Polar2PVector ( a->size + b->size, a_ang );
	}
      else
	{
	  b2a = a->pos - b->pos;
	  b2a.r ( a->size + b->size );
	}

      apos = b->pos + b2a;          
    }
  else
    {
      PVector mid = a->pos + b->pos;
      mid /= 2.0;

      PVector mid2a = a->pos - mid;
      PVector mid2b = b->pos - mid;

      /* pfr 10/25/01
	 This was a really nasty bug. This used to be the condition
	 if ( a->pos == b->pos )
	 If a->pos and b->pos are approximately equal (but
	 not ==, then a->pos - mid and b->pos - mid can both be 0.
	 This means that in the else clause below, we call PVector::r(v)
	 on two zero vectors, which makes them both (v,0).
	 Then, the while statement below is an infinite loop */
      if ( a->pos == b->pos
	   || ( a->pos - mid == 0 && b->pos - mid == 0 )
	   )
	{
	  // if the two objects are directly on top on one and other
	  // then they will be sperated at a random angle
	  Angle a_ang = drand ( -PI, PI );
	  Angle b_ang = normalize_angle ( a_ang + PI );
	  mid2a = Polar2PVector ( ( a->size + b->size ) / 2.0 , a_ang );
	  mid2b = Polar2PVector ( ( a->size + b->size ) / 2.0 , b_ang );
	}
      else
	{
	  mid2a.r ( ( a->size + b->size ) / 2.0 );
	  mid2b.r ( ( a->size + b->size ) / 2.0 );
	}

      apos = mid + mid2a;
      bpos = mid + mid2b;

      // 0.01% is added to the movement, as sometimes structural noise
      // means that even though mid2a and mid2b should be 
      // a->size + b->size apart, they are ever so slightly
      // less.
      int count = 0;
      while ( apos.distance ( bpos ) < a->size + b->size
	      && count < 10 )
	{
	  mid2a.r ( mid2a.r () * 1.0001 );
	  mid2b.r ( mid2b.r () * 1.0001 );
	  apos = mid + mid2a;
	  bpos = mid + mid2b;
	  count++;
	}
    }


/*    cout << "apos = " << a->pos << std::endl; */
/*    cout << "anewpos = " << (mid + mid2a ) << std::endl; */

/*    cout << "bpos = " << b->pos << std::endl; */
/*    cout << "bnewpos = " << (mid + mid2b ) << std::endl; */

/*    cout << "old distance = " << a->pos.distance ( b->pos ) << std::endl; */
/*    cout << "new distance = " << apos.distance ( bpos ) << std::endl; */

  a->post_col_pos += apos;
  b->post_col_pos += bpos;
  a->col_count++;
  b->col_count++;

  a->col = true;
  b->col = true;
   
}

void moveToCollPos ( MPObject* obj )
{
  if ( obj == NULL )
    return;

  if ( obj->col_count > 0 )
    {
/*        cout << "oldpos = " << obj->pos << std::endl; */
/*        cout << "colpos = " << obj->post_col_pos << std::endl; */
/*        cout << "colcount = " << obj->col_count << std::endl; */
      obj->post_col_pos /= obj->col_count;
      obj->pos = obj->post_col_pos;
/*        cout << "newpos = " << obj->pos << std::endl; */
    }

  obj->post_col_pos = PVector ( 0, 0 );
  obj->col_count = 0;
}

void updateCollVel ( MPObject* obj )
{
  if ( obj == NULL )
    return;

  if ( obj->col )
    {
      obj->vel *= -0.1;
      obj->col = false;
    }
}


void MPObjectTable::_turn()
{
	TheNumber i ;
	int sw ;
	MPObject **obj ;
	MPObject *buf ;

	obj = object ;

	/* randomize order */
	for(i = 0; i < n ; i++) {
		sw = irand(n) ;
		buf = *(obj+i) ;
		*(obj+i) = *(obj+sw) ;
		*(obj+sw) = buf ;
	}

	for(i = 0; i < n ; i++) {
		(**obj)._turn() ;
		obj++ ;
	}
}

/*
 *===================================================================
 *Part: Player & Team
 *===================================================================
 */


Team::Team(Stadium *stad, const Side s)
{
	stadium = stad ;
	enable = FALSE ;
	name = NULLCHAR ;
	side = s ;

	subs = 0;
	for ( int i = 0; i < 7; i++ )
	    ptype_count [ i ] = 0;
	
#ifdef NEW_QSTEP
	if (side == LEFT ){
		dist_qstep_team = ServerParam::instance().dist_qstep_l ;
		land_qstep_team = ServerParam::instance().land_qstep_l ;
		dir_qstep_team  = ServerParam::instance().dir_qstep_l ;
	} else {
		dist_qstep_team = ServerParam::instance().dist_qstep_r ;
		land_qstep_team = ServerParam::instance().land_qstep_r ;
		dir_qstep_team  = ServerParam::instance().dir_qstep_r ;
	}
#endif
	// pfr 8/14/00: for RC2000 evaluation
	if( ServerParam::instance().team_actuator_noise) {
	  if (side == LEFT ){
	    prand_factor_team     = ServerParam::instance().prand_factor_l;
	    kick_rand_factor_team = ServerParam::instance().kick_rand_factor_l;
	  } else {
	    prand_factor_team     = ServerParam::instance().prand_factor_r;
	    kick_rand_factor_team = ServerParam::instance().kick_rand_factor_r;
	  }
	}

	Max = MAX_PLAYER ; 
	point = 0 ;
        pen_point = 0;
        pen_taken = 0;
        pen_won = false;
	n = 0 ;
	goalie = FALSE ;
	player = new Player*[Max] ;
}

Team::~Team()
{
  for( GraphCont::iterator i = M_graphics.begin(); i != M_graphics.end(); ++i )
    delete i->second;
}

Player *Team::newPlayer(Value version, int goalie_flag) 
{
	if (n >= Max) {
		if (ServerParam::instance().verbose)
			std::cerr << "Warning:Too many players." << std::endl ;
		return (Player*)NULL ;
	}

	if (goalie && goalie_flag) {
		if (ServerParam::instance().verbose)
			std::cerr << "Warning:Too many goalies." << std::endl ;
		return (Player*)NULL ;
	}

	if (goalie_flag)
		goalie = TRUE ;

	Player *p = player[n] ;
	
	p->init(version, goalie_flag) ;

	if( !p->setSenders() )
	{
//          typedef const rcss::SerializerPlayer&(*SerCreator)();    
//          typedef rcss::ObjFact< SerCreator, int > SerFactory;

//          const rcss::SerializerPlayer& ser = SerFactory().getCreator( (int)version )();
 
//          rcss::BodySenderPlayer::Params body_params( p->getTransport(),
//                                                      *p,
//                                                      ser );
 
//          typedef std::auto_ptr< rcss::BodySenderPlayer >(*BodyCreator)( const rcss::BodySenderPlayer::Params& );
//          p->setBodySender( rcss::ObjFact< BodyCreator, int >().getCreator( (int)version )( body_params ) );

//          rcss::VisualSenderPlayer::Params visual_params( p->getTransport(),
//                                                          *p,
//                                                          *stadium,
//                                                          ser );

//          typedef std::auto_ptr< rcss::VisualSenderPlayer >(*VisCreator)( const rcss::VisualSenderPlayer::Params& );
//          p->setVisualSender( rcss::ObjFact< VisCreator, int >().getCreator( (int)version )( visual_params ) );


//          rcss::InitSenderPlayer::Params init_params( p->getTransport(),
//                                                      *p,
//                                                      *stadium,
//                                                      ser );

//          typedef std::auto_ptr< rcss::InitSenderPlayer >(*InitCreator)( const rcss::InitSenderPlayer::Params& );
//          p->setInitSender( rcss::ObjFact< InitCreator, int >().getCreator( (int)version )( init_params ) );      

        
//          rcss::FullStateSenderPlayer::Params fs_params( p->getTransport(),
//                                                         *p,
//                                                         *stadium,
//                                                         ser );

//          typedef std::auto_ptr< rcss::FullStateSender >(*FSCreator)( const rcss::FullStateSenderPlayer::Params& );
//          p->setFullStateSender( rcss::ObjFact< FSCreator, int >().getCreator( (int)version )( fs_params ) );

 
//          rcss::AudioSenderPlayer::Params audio_params( *stadium,
//                                                        p->getTransport(),
//                                                        *p,
//                                                        ser );
//          typedef std::auto_ptr< rcss::AudioSender >(*AudCreator)( const rcss::AudioSenderPlayer::Params& );
//          p->setAudioSender( rcss::ObjFact< AudCreator, int >().getCreator( (int)version )( audio_params ) );

	    cerr << "Error: Could not find serializer or sender for version " 
		 << (int)p->version << endl;
	    return NULL;
	} 
    
    
    n++ ;
    ptype_count [ 0 ] = ptype_count [ 0 ] + 1;
    
    stadium->addListener( p );
	return p ;
}


OnlineCoach::OnlineCoach(Stadium *stad)
  : Coach(stad)
{
  angle = Deg2Rad(90) ;
  side = FALSE ;
  freeform_messages_said = 0;
  freeform_messages_allowed = -1;
  define_messages_left = -1;
  advice_messages_left = -1;
  info_messages_left = -1;
  meta_messages_left = -1;
  del_messages_left = -1;
  rule_messages_left = -1;
  msg_left_update_time = -1;
} 

bool OnlineCoach::update_messages_left(TheNumber time)
{
  if (msg_left_update_time >= 0 &&
      time - msg_left_update_time < ServerParam::instance().clang_win_size)
    return false;

  define_messages_left = ServerParam::instance().clang_define_win;
  meta_messages_left = ServerParam::instance().clang_meta_win;
  advice_messages_left = ServerParam::instance().clang_advice_win;
  info_messages_left = ServerParam::instance().clang_info_win;
  del_messages_left = ServerParam::instance().clangDelWin();
  rule_messages_left = ServerParam::instance().clangRuleWin();

  msg_left_update_time = time;

  return true;
}

void
Team::addGraphic( unsigned int x, 
                  unsigned int y,
                  std::auto_ptr< XPMHolder > holder )
{
  GraphKey key( x, y );
  GraphCont::iterator i = M_graphics.find( key );
  if( i != M_graphics.end() )
    delete i->second;

  M_graphics[ key ] = holder.release();
}