memplayer.c

RoboCup 2D 仿真组冠军源代码之1998年冠军队——CMUnited98源代码

    if (stamina >= SP_effort_inc_thr * SP_stamina_max && effort < 1.0){
      effort += SP_effort_inc;
      if ( effort > 1.0 )
	effort = 1.0;
    }
    stamina += recovery * SP_stamina_inc;
    if ( stamina > SP_stamina_max )
      stamina = SP_stamina_max;
  }
}

/*********************************************************************************/

void PlayerInfo::reset_stamina()
{
  /* right now, effort and recovery aren't reset */
  stamina = SP_stamina_inc;
  /* effort = 1.0; */
}

/*********************************************************************************/

Time PlayerInfo::update_time(int time)
{
  LastTime = CurrentTime;

  if ( ClockStopped ){
    if ( CurrentTime.t != time ){
      if ( CurrentTime.t == time - 1 ) /* Sometimes happens in offsides mode */
	CurrentTime = Time(time,0);
      else
	my_error("server time should be the same %d %d %d",CurrentTime.t, CurrentTime.s, time);
    }
    else 
      CurrentTime.s = StoppedClockMSec/SP_simulator_step;
  }
  else if ( LastStartClockTime.t == time )
    CurrentTime = LastStartClockTime;
  else
    CurrentTime = Time(time,0);
  
  return CurrentTime;
}




/*********************************************************************************/
/*********************************************************************************/
/*********************************************************************************/

AngleDeg PlayerInfo::MyViewAngle(Time time)
{
  AngleDeg view_angle = SP_visible_angle;
  Vwidth width;

  if ( time < ViewWidthTime ) 
    width = LastViewWidth;
  else 
    width = ViewWidth;

  if ( width == VW_Narrow ) view_angle /= 2;
  else if ( width == VW_Wide ) view_angle *= 2;

  return view_angle/2;
}

/*********************************************************************************/

Bool PlayerInfo::InViewAngle(Time time, AngleDeg ang, float buffer)
{
  if ( fabs(ang) < MyViewAngle(time) - buffer ) return TRUE;
  return FALSE;
}

/*********************************************************************************/

int PlayerInfo::MySightInterval()
{
  int interval = SP_send_step;
  
  if ( ViewWidth == VW_Narrow ) interval /= 2;
  else if ( ViewWidth == VW_Wide ) interval *= 2;

  if ( ViewQuality == VQ_Low ) interval /=2;

  return interval;
}

/*********************************************************************************/

int PlayerInfo::PredictedNextSightInterval()
{
  switch(MySightInterval()){
  case 37: 
  case 75: return 1;
  case 300: return 3;
  case 150: return (LastSightInterval <= 1 ? 2 : 1);
  default: my_error("Sight interval should be 37, 75, 150, or 300: %d",MySightInterval());
  }
  return 0;
}

/*********************************************************************************/

void PlayerInfo::SetMySensedInfo(float st, float e, float sp, int k, int d, int tu, int sa, Time ti)
{
  if ( sense_time == ti )
    return;

  prev_sense_time = sense_time;
  sense_time      = ti;

  prev_stamina    = last_stamina;
  last_stamina    = st;
  prev_effort     = last_effort;
  last_effort     = e;
  prev_speed      = last_speed;
  last_speed      = sp;

  prev_kicks     = last_kicks;
  last_kicks     = k;
  if ( last_kicks != kicks ){
     my_error("Server missed a kick at time %d (%d %d)",prev_sense_time.t,last_kicks,kicks);
     LastAction->type = CMD_none;
     kicks = last_kicks;
     Mem->GetBall()->forget_past_kick(LastAction->time);
     /* RequestResend = TRUE;
     ResendType    = CMD_kick;
     ResendTime    = LastActionTime(); */
  }

  prev_dashes    = last_dashes;
  last_dashes    = d;
  if ( last_dashes != dashes ){
     my_error("Server missed a dash at time %d (%d %d)",prev_sense_time.t,last_dashes,dashes);
     LastAction->type = CMD_none;
     dashes = last_dashes;
     /* RequestResend = TRUE;
     ResendType   = CMD_dash;
     ResendTime    = LastActionTime(); */
  }

  prev_turns     = last_turns;
  last_turns     = tu;
  if ( last_turns != turns ){
     my_error("Server missed a turn at time %d (%d %d)",prev_sense_time.t,last_turns,turns);
     LastAction->type = CMD_none;
     turns = last_turns;
     /* RequestResend = TRUE;
     ResendType   = CMD_turn;
     ResendTime    = LastActionTime(); */
  }

  prev_says      = last_says;
  last_says      = sa;
  if ( last_says != says ){
    says = last_says;
  }
}

/*********************************************************************************/

float PlayerInfo::GetMySensedSpeed(Time time){

  if (time == sense_time)
    return last_speed;
  if (time == prev_sense_time)
    return prev_speed;

  my_error("Don't know my speed at time %d",time.t);
  return 0;
}

/*********************************************************************************/

float PlayerInfo::GetMySensedStamina(Time time){

  if (time == sense_time)
    return last_stamina;
  if (time == prev_sense_time)
    return prev_stamina;

  my_error("Don't know my stamina at time %d",time.t);
  return 0;
}

/*********************************************************************************/

float PlayerInfo::GetMySensedEffort(Time time){

  if (time == sense_time)
    return last_effort;
  if (time == prev_sense_time)
    return prev_effort;

  my_error("Don't know my effort at time %d",time.t);
  return 0;
}

/*********************************************************************************/

int PlayerInfo::GetMySensedKicks(Time time){

  if (time == sense_time)
    return last_kicks;
  if (time == prev_sense_time)
    return prev_kicks;

  my_error("Don't know my kicks at time %d",time.t);
  return 0;
}

/*********************************************************************************/

int PlayerInfo::GetMySensedDashes(Time time){

  if (time == sense_time)
    return last_dashes;
  if (time == prev_sense_time)
    return prev_dashes;

  my_error("Don't know my dashes at time %d",time.t);
  return 0;
}

/*********************************************************************************/

int PlayerInfo::GetMySensedTurns(Time time){

  if (time == sense_time)
    return last_turns;
  if (time == prev_sense_time)
    return prev_turns;

  my_error("Don't know my turns at time %d",time.t);
  return 0;
}

/*********************************************************************************/

int PlayerInfo::GetMySensedSays(Time time){

  if (time == sense_time)
    return last_says;
  if (time == prev_sense_time)
    return prev_says;

  my_error("Don't know my says at time %d",time.t);
  return 0;
}

/*********************************************************************************/

float PlayerInfo::CorrectDashPowerForStamina(float dash_power, float stamina, float, float)
{
  int sign = Sign(dash_power);
  float new_power = fabs(dash_power);
  new_power = Min( new_power, stamina-(EffortDecThreshold+CP_tired_buffer) );

  if ( new_power < 0 ) new_power = 0;
  new_power *= sign;

  return new_power;
}

/*********************************************************************************/

Vector PlayerInfo::MyPredictedPositionAtMaxSpeed(int steps)
{
  if ( !MyConf() ) my_error("Can't estimate future if don't know present (max speed)");

  Vector new_position = MyPos();
  Vector max_velocity = Polar2Vector(SP_player_speed_max,MyAng());
  for (int i=0; i<steps; i++){
    new_position += max_velocity;
  }
  return new_position;
}

/*********************************************************************************/

Vector PlayerInfo::MyPredictedPositionWithTurn(float turn_ang,
					       int steps, float dash_power,
					       bool with_turn)
{
  if ( !MyConf() ) my_error("Can't estimate future if don't know present");
  
  float corrected_dash_power = dash_power;
  float effective_power;
  float predicted_stamina = MyStamina();
  float predicted_effort = MyEffort();
  float predicted_recovery = MyRecovery();
  float myang = MyAng();
  Vector position = MyPos();
  Vector velocity;
  if ( !MyVelConf() ) velocity = 0;
  else                velocity = MyVel();
  /* debug code 
  cout << "steps: " << steps << "\tpow: " << dash_power << "\tmyang: " << myang
       << "\tposition: " << position << "\tvel: " << velocity
       << "\tturn?: " << turn_first << "\tturn_ang: " << turn_angle
       << "\tstam: " << predicted_stamina << "\teff: " << predicted_effort
       << "\trec: " << predicted_recovery << endl; */
    
  for (int i=0; i<steps; i++){
    corrected_dash_power = CorrectDashPowerForStamina(dash_power,predicted_stamina);
    /* cout << " in func: i=" << i << "\tpos" << position << endl; */
    if (i==0 && with_turn) {
      myang += turn_ang;
      effective_power = 0;
    } else if (fabs(corrected_dash_power) > predicted_stamina)
      effective_power = Sign(corrected_dash_power) * predicted_stamina ;
    else
      effective_power = corrected_dash_power;
    
    effective_power *= predicted_effort;
    effective_power *= SP_dash_power_rate;
    velocity += Polar2Vector( effective_power, myang );
    /* cout << " in func: i=" << i << "\tvel" << velocity << endl; */
    
    if ( velocity.mod() > SP_player_speed_max )
      velocity *= ( SP_player_speed_max/velocity.mod() );
    
    position += velocity;
    velocity *= SP_player_decay;

    predicted_stamina -= predicted_effort * fabs(corrected_dash_power);
    if (predicted_stamina < 0) predicted_stamina = 0;

    if ( predicted_stamina <= SP_recover_dec_thr * SP_stamina_max && predicted_recovery > SP_recover_min ) {
      predicted_recovery -= SP_recover_dec;
    }

    if ( predicted_stamina <= SP_effort_dec_thr * SP_stamina_max && predicted_effort > SP_effort_min )
      predicted_effort -= SP_effort_dec;
    if (predicted_stamina >= SP_effort_inc_thr * SP_stamina_max && predicted_effort < 1.0){
      predicted_effort += SP_effort_inc;
      if ( predicted_effort > 1.0 )
	predicted_effort = 1.0;
    }
    predicted_stamina += predicted_recovery * SP_stamina_inc;
    if ( predicted_stamina > SP_stamina_max )
      predicted_stamina = SP_stamina_max;
  }

  /* cout << "returning " << position << endl; */
  return position;
  
}