memplayer.c

1999年卡耐基梅陇大学的2D仿真源代码

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

float PlayerInfo::GetMySensedNeckAngle(Time time){

  if (time == sense_time)
    return last_neck_rel_ang;
  if (time == prev_sense_time)
    return prev_neck_rel_ang;

  my_error("Don't know my neck angle 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;
}

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

int PlayerInfo::GetMySensedTurnNecks(Time time){

  if (time == sense_time)
    return last_turn_necks;
  if (time == prev_sense_time)
    return prev_turn_necks;

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

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

float PlayerInfo::CorrectDashPowerForStamina(float dash_power, float stamina, float, float)
{
  float new_power;
  if (dash_power >= 0) {
    new_power = Min( dash_power, stamina-(EffortDecThreshold+CP_tired_buffer) );
    if ( new_power < 0 ) new_power = 0;
  } else {
    new_power = Min( -dash_power, stamina-(EffortDecThreshold+CP_tired_buffer) / 2.0);
    if ( new_power < 0 ) new_power = 0;

    new_power = -new_power;
  }
    
  return new_power;
}

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

Bool PlayerInfo::CanFaceAngleFromNeckWithNeck(AngleDeg ang)
{
  AngleDeg total_ang = MyNeckRelAng() + ang;
  NormalizeAngleDeg(&total_ang);
  if ( total_ang > SP_min_neck_angle && total_ang < SP_max_neck_angle )
    return TRUE;
  return FALSE;
}

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

Bool PlayerInfo::CanFaceAngleFromBodyWithNeck(AngleDeg ang)
{
  NormalizeAngleDeg(&ang);
  if ( ang > SP_min_neck_angle && ang < SP_max_neck_angle )
    return TRUE;
  return FALSE;
}

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

Bool PlayerInfo::CanSeeAngleFromNeckWithNeck(AngleDeg ang)
{
  AngleDeg total_ang = MyNeckRelAng() + ang;
  NormalizeAngleDeg(&total_ang);
  if ( total_ang > SP_min_neck_angle - MyViewAngle() && 
       total_ang < SP_max_neck_angle + MyViewAngle() )
    return TRUE;
  return FALSE;
}

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

Bool PlayerInfo::CanSeeAngleFromBodyWithNeck(AngleDeg ang)
{
  if (ang > 180 || ang < -180) {
    my_error("Passing unnormalized angle to CanSeeAngleFromBodyWithNeck: %.1f", ang);
    NormalizeAngleDeg(&ang);
  }
  if ( ang > SP_min_neck_angle - MyViewAngle() && 
       ang < SP_max_neck_angle + MyViewAngle() )
    return TRUE;
  return FALSE;
}

/*********************************************************************************/
/*********************************************************************************/
/*********************************************************************************/
void PlayerInfo::UpdatePredictedStaminaWithDash(float* pStamina, float* pEffort,
						float* pRecovery, float dash_power)
{
  if (dash_power > 0)
    *pStamina -= dash_power;
  else
    *pStamina -= 2 * dash_power;
  if (*pStamina < 0) *pStamina = 0;

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

  if ( *pStamina <= SP_effort_dec_thr * SP_stamina_max && *pEffort > SP_effort_min )
    *pEffort -= SP_effort_dec;
  if (*pStamina >= SP_effort_inc_thr * SP_stamina_max && *pEffort < 1.0){
    *pEffort += SP_effort_inc;
    if ( *pEffort > 1.0 )
      *pEffort = 1.0;
  }
  *pStamina += *pRecovery * SP_stamina_inc;
  if ( *pStamina > SP_stamina_max )
    *pStamina = SP_stamina_max;
}

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


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,MyBodyAng());
  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,
					       int idle_cycles)
{
  if ( !MyConf() ) my_error("Can't estimate future if don't know present");
  
  float curr_turn_ang = GetNormalizeAngleDeg(turn_ang);
  float corrected_dash_power = dash_power;
  float effective_power;
  float predicted_stamina = MyStamina();
  float predicted_effort = MyEffort();
  float predicted_recovery = MyRecovery();
  float myang = MyBodyAng();
  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 < idle_cycles) {
      /* do nothing, we're idling! */
      effective_power = 0;
    } else if (with_turn &&
	(i==0 || curr_turn_ang != 0.0)) {
      float this_turn = MinMax(-EffectiveTurn(SP_max_moment, velocity.mod()),
			       curr_turn_ang,
			       EffectiveTurn(SP_max_moment, velocity.mod()));
      myang += this_turn;
      curr_turn_ang -= this_turn;
      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;

    UpdatePredictedStaminaWithDash(&predicted_stamina, &predicted_effort,
				   &predicted_recovery, corrected_dash_power);

    /*
    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;
  
}

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

Vector PlayerInfo::MyPredictedPositionWithQueuedActions()
{
  /* Only goes one step in the future so far (other function assumes repeated dashes) */
  if ( Action->valid() && Action->type == CMD_dash )
    return MyPredictedPosition(1,Action->power);
  else
    return MyPredictedPosition();
}

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

AngleDeg PlayerInfo::MyPredictedBodyAngleWithQueuedActions()
{
  /* Only goes one step in the future so far (other function assumes repeated dashes) */
  if ( Action->valid() && Action->type == CMD_turn )
    return GetNormalizeAngleDeg(MyBodyAng() + EffectiveTurn(Action->angle));
  else
    return MyBodyAng();
}

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

AngleDeg PlayerInfo::PredictedPointRelAngFromBodyWithQueuedActions(Vector point)
{
    Vector   pred_my_pos             = MyPredictedPositionWithQueuedActions();
    AngleDeg pred_my_body_ang        = MyPredictedBodyAngleWithQueuedActions();
    Vector   pred_relative_point_pos = point - pred_my_pos;
    AngleDeg target_abs_ang          = pred_relative_point_pos.dir();
    AngleDeg target_rel_ang          = target_abs_ang - pred_my_body_ang;
    NormalizeAngleDeg(&target_rel_ang);
    
    return target_rel_ang;
}

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

int PlayerInfo::PredictedCyclesToPoint(Vector pt, float dash_power)
{
  float corrected_dash_power = dash_power;
  float effective_power;
  float predicted_stamina = MyStamina();
  float predicted_effort = MyEffort();
  float predicted_recovery = MyRecovery();
  float myang = MyBodyAng();
  Vector position = MyPos();
  Vector velocity;
  if ( !MyVelConf() ) velocity = 0;
  else                velocity = MyVel();

  for (int i=0; TRUE; i++) {
    if (position.dist(pt) <= CP_at_point_buffer)
      return i;

    /* decide if we should turn */
    float targ_ang = (pt-position).dir() - myang;
    if (fabs(GetNormalizeAngleDeg(targ_ang)) > CP_max_go_to_point_angle_err) {
      /* turning */
      float this_turn = MinMax(-EffectiveTurn(SP_max_moment, velocity.mod()),
			       targ_ang,
			       EffectiveTurn(SP_max_moment, velocity.mod()));
      myang += this_turn;
      corrected_dash_power = 0; //so that stamina is updated correctly
    } else {
      /* dashing */
      corrected_dash_power = CorrectDashPowerForStamina(dash_power,predicted_stamina);
      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 );
    }
    
    if ( velocity.mod() > SP_player_speed_max )
      velocity *= ( SP_player_speed_max/velocity.mod() );
    
    position += velocity;
    velocity *= SP_player_decay;

    UpdatePredictedStaminaWithDash(&predicted_stamina, &predicted_effort,
				   &predicted_recovery, corrected_dash_power);
    
  }
  
}

/*********************************************************************************/
int PlayerInfo::NumTurnsToAngle(float targ_body_ang, float curr_body_ang, float curr_speed)
{
  int steps;

  NormalizeAngleDeg(&targ_body_ang);
  NormalizeAngleDeg(&curr_body_ang);

  for (steps = 0;
       fabs(targ_body_ang - curr_body_ang) > CP_max_go_to_point_angle_err;
       steps++) {
    AngleDeg this_turn = targ_body_ang - curr_body_ang;
    NormalizeAngleDeg(&this_turn);
    this_turn = signf(this_turn)*Min(fabs(this_turn), MaxEffectiveTurn(curr_speed));
    Mem->LogAction5(210, "NumTurnsToAngle: curr: %.1f  targ: %.1f  turn: %.1f",
		    curr_body_ang, targ_body_ang, this_turn);
    curr_body_ang += this_turn;
    NormalizeAngleDeg(&curr_body_ang);
    curr_speed *= SP_player_decay;
  }
  
  return steps;
}



/*********************************************************************************/
/*********************************************************************************/
/*********************************************************************************/
/* returns whether we're trying to send a command too soon after the previous command.
   Helps to keep us from missing commands */
/* Not needed after server 5.23
Bool PlayerInfo::TooSoonForAnotherSend()
{
  struct timeval tv_new;

  gettimeofday(&tv_new, NULL); // no time zone info;
  int usec_diff = (tv_new.tv_sec - real_time_of_last_send.tv_sec) * 1000000 +
    ((signed)tv_new.tv_usec - (signed)real_time_of_last_send.tv_usec);
  return (usec_diff < Mem->SP_recv_step*1000 / Mem->CP_send_ban_recv_step_factor)
    ? TRUE : FALSE;
}
*/