memplayer.c

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

/* -*- Mode: C++ -*- */


/* MemPlayer.C
 * CMUnited99 (soccer client for Robocup99)
 * Peter Stone <[e-mail]>
 * Computer Science Department
 * Carnegie Mellon University
 * Copyright (C) 1999 Peter Stone
 *
 * CMUnited-99 was created by Peter Stone, Patrick Riley, and Manuela Veloso
 *
 * You may copy and distribute this program freely as long as you retain this notice.
 * If you make any changes or have any comments we would appreciate a message.
 * For more information, please see http://www.cs.cmu.edu/~robosoccer/
 */

#include "types.h"
#include "MemPlayer.h"
#include "client.h"

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

PlayerInfo::PlayerInfo()
{
  Initialized = FALSE;
  ServerAlive = FALSE;
  CoachActive = FALSE;
  ViewQuality = VQ_High;
  ViewWidth   = VW_Normal;
  NewSight = FALSE;
  NewAction = FALSE;
  FirstActionOpSinceLastSight = FALSE;
  ClockStopped = FALSE;
  StoppedClockMSec = 0;
  LastStartClockTime = Time(-1,0); /* If a problem, change back to 0,0 */
  SecondLastStartClockTime = LastStartClockTime;
  CurrentTime = 0;
  LastSightTime = LastSoundTime = LastActionOpTime = Time(0, 0);
  PlayModeTime = 0;
  PlayMode = PM_Before_Kick_Off;

  Action = new Command;
  LastAction = new Command;
  RequestResend = FALSE;

  last_dashes = prev_dashes = dashes = 0;
  last_turns  = prev_turns  = turns  = 0;
  last_kicks  = prev_kicks  = kicks  = 0;
  last_says   = prev_says   = says   = 0;
  last_turn_necks   = prev_turn_necks   = turn_necks   = 0;

  TheirTeamName[0] = '\n';

  conf=0;

  body_ang = 0;
  neck_rel_ang = 0;
}

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

PlayerInfo::~PlayerInfo()
{
  if (CP_save_log)
    fclose(SaveLogFile);

  if (CP_save_sound_log)
    fclose(SaveSoundLogFile);

  if (CP_save_action_log_level > 0)
    fclose(SaveActionLogFile);
  
  delete Action;
  delete LastAction;
}

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

void PlayerInfo::Initialize()
{
  /* printf("Calling Player Initialize\n"); */

  TheirSide = ( MySide == 'l' ? 'r' : 'l' );
  MyTeamNameLen = strlen(MyTeamName);

  TestVersion = (VP_test || ( MySide == 'l' && VP_test_l ) || ( MySide == 'r' && VP_test_r )) ? TRUE : FALSE;
  if ( TestVersion == TRUE ) printf("%d : test version\n",MyNumber);
  if ( VP_train_DT == TRUE ) printf("%d : training DT\n",MyNumber);

  MyScore    = IP_my_score;
  TheirScore = IP_their_score;

  if (CP_save_log){
    sprintf(SaveLogFileName,"Logfiles/%s%d-%c.log",MyTeamName,(int)MyNumber,MySide);
    SaveLogFile = fopen(SaveLogFileName,"w");
    SaveLogCounter = 0;
  }

  if (CP_save_sound_log){
    sprintf(SaveSoundLogFileName,"Logfiles/%s%d-%c-sounds.log",MyTeamName,(int)MyNumber,MySide);
    SaveSoundLogFile = fopen(SaveSoundLogFileName,"w");
    SaveSoundLogCounter = 0;
  }

  if (CP_save_action_log_level > 0){
    sprintf(SaveActionLogFileName,"Logfiles/%s%d-%c-actions.log",MyTeamName,(int)MyNumber,MySide);
    SaveActionLogFile = fopen(SaveActionLogFileName,"w");
    SaveActionLogCounter = 0;
  }

  TimerInterval = SP_simulator_step/CP_interrupts_per_cycle;

  stamina = SP_stamina_max;
  effort = 1;
  recovery = 1;

  neck_rel_ang = 0;

  RecoveryDecThreshold = SP_stamina_max * SP_recover_dec_thr;
  EffortDecThreshold   = SP_stamina_max * SP_effort_dec_thr;
  EffortIncThreshold   = SP_stamina_max * SP_effort_inc_thr;

  my_vel_time = my_pos_time = 0;

  LastInterruptTime = 0;
  InterruptsThisCycle = 0;						  

  Initialized = TRUE;
}


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

#ifndef NO_ACTION_LOG

#define MAX_LOG_LINE 150

/* will be timestamped automatically */
void PlayerInfo::LogAction2(int level, char* str)
{
  if (level <= 0 ||
      level > CP_save_action_log_level)
    return;

  if (!Initialized)
    return; /* the log files hasn't been opened yet! */

  fprintf(Mem->SaveActionLogFile, "%d.%d %s%s\n", CurrentTime.t, CurrentTime.s,
	  repeat_char('-', level / 10), str);
  if (Mem->SaveActionLogCounter++ % Mem->CP_save_action_freq == 0){
    fclose(Mem->SaveActionLogFile);
    Mem->SaveActionLogFile = fopen(Mem->SaveActionLogFileName,"a");
  }

}

void PlayerInfo::LogAction3(int level, char* str, char* param)
{
  char outstring[MAX_LOG_LINE];
  sprintf(outstring, str, param);
  LogAction2(level, outstring);
}

void PlayerInfo::LogAction4(int level, char* str, char* param1, char* param2)
{
  char outstring[MAX_LOG_LINE];
  sprintf(outstring, str, param1, param2);
  LogAction2(level, outstring);
}

void PlayerInfo::LogAction3(int level, char* str, char c1)
{
  char outstring[MAX_LOG_LINE];
  sprintf(outstring, str, c1);
  LogAction2(level, outstring);
}

void PlayerInfo::LogAction3(int level, char* str, float f1)
{
  char outstring[MAX_LOG_LINE];
  sprintf(outstring, str, f1);
  LogAction2(level, outstring);
}

void PlayerInfo::LogAction4(int level, char* str, float f1, int d1)
{
  char outstring[MAX_LOG_LINE];
  sprintf(outstring, str, f1, d1);
  LogAction2(level, outstring);
}

void PlayerInfo::LogAction4(int level, char* str, float f1, float f2)
{
  char outstring[MAX_LOG_LINE];
  sprintf(outstring, str, f1, f2);
  LogAction2(level, outstring);
}

void PlayerInfo::LogAction5(int level, char* str, float f1, float f2, float f3)
{
  char outstring[MAX_LOG_LINE];
  sprintf(outstring, str, f1, f2, f3);
  LogAction2(level, outstring);
}

void PlayerInfo::LogAction6(int level, char* str, float f1, float f2, float f3, float f4)
{
  char outstring[MAX_LOG_LINE];
  sprintf(outstring, str, f1, f2, f3, f4);
  LogAction2(level, outstring);
}

void PlayerInfo::LogAction7(int level, char* str, float f1, float f2, float f3, float f4, float f5)
{
  char outstring[MAX_LOG_LINE];
  sprintf(outstring, str, f1, f2, f3, f4, f5);
  LogAction2(level, outstring);
}

void PlayerInfo::LogAction8(int level, char* str, float f1, float f2, float f3, float f4, float f5, float f6)
{
  char outstring[MAX_LOG_LINE];
  sprintf(outstring, str, f1, f2, f3, f4, f5, f6);
  LogAction2(level, outstring);
}

void PlayerInfo::LogAction3(int level, char* str, int d1)
{
  char outstring[MAX_LOG_LINE];
  sprintf(outstring, str, d1);
  LogAction2(level, outstring);
}

void PlayerInfo::LogAction4(int level, char* str, int d1, int d2)
{
  char outstring[MAX_LOG_LINE];
  sprintf(outstring, str, d1, d2);
  LogAction2(level, outstring);
}

void PlayerInfo::LogAction4(int level, char* str, int d1, float f1)
{
  char outstring[MAX_LOG_LINE];
  sprintf(outstring, str, d1, f1);
  LogAction2(level, outstring);
}

void PlayerInfo::LogAction5(int level, char* str, int d1, float f1, float f2)
{
  char outstring[MAX_LOG_LINE];
  sprintf(outstring, str, d1, f1, f2);
  LogAction2(level, outstring);
}

void PlayerInfo::LogAction6(int level, char* str, int d1, float f1, float f2, float f3)
{
  char outstring[MAX_LOG_LINE];
  sprintf(outstring, str, d1, f1, f2, f3);
  LogAction2(level, outstring);
}

void PlayerInfo::LogAction7(int level, char* str, int d1, float f1, float f2, float f3, float f4)
{
  char outstring[MAX_LOG_LINE];
  sprintf(outstring, str, d1, f1, f2, f3, f4);
  LogAction2(level, outstring);
}

void PlayerInfo::LogAction7(int level, char* str, int d1, int d2, float f1, float f2, float f3)
{
  char outstring[MAX_LOG_LINE];
  sprintf(outstring, str, d1, d2, f1, f2, f3);
  LogAction2(level, outstring);
}


#endif /* ifndef NO_ACTION_LOG */

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

void PlayerInfo::SetPlayMode(Pmode mode)
{
  /* If clock is starting, save the old time */
  if ( ClockStopped ){
    ClockStopped = FALSE;
    SecondLastStartClockTime = LastStartClockTime;
    LastStartClockTime = LastActionOpTime;
    StoppedClockMSec = 0; 

    sanitize_time(CurrentTime);
    sanitize_time(LastSightTime);
    sanitize_time(LastSoundTime);
    sanitize_time(sense_time);
  }

  if ( (PlayMode!=PM_My_Goalie_Free_Kick && PlayMode!=PM_Their_Goalie_Free_Kick) || 
       PlayModeTime != CurrentTime ){ /* Already set the play mode for this time */
    LastPlayMode = PlayMode;
    PlayMode = mode;
    PlayModeTime = CurrentTime;
  }

  if ( mode == PM_Before_Kick_Off || mode == PM_My_Offside_Kick || mode == PM_Their_Offside_Kick ){
    if ( StoppedClockMSec != 0 ) my_error("StoppedClockMSec should have been reset already");
    ClockStopped = TRUE;
  }
  
  if (mode == PM_Half_Time || mode == PM_Extended_Time)
    reset_stamina();


/* in others: */
//    if ( Mem->QActionTaken )
//      Mem->CloseRewards();

}

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

void PlayerInfo::sanitize_time(Time &tm)
{
  if ( !LastStartClockTime ) return;

  /* This is to take care of times that were prematurely updated before we knew that
     the clock was about to start again */
  if ( tm.t == LastStartClockTime.t && tm.s > LastStartClockTime.s ){
    tm = Time( LastStartClockTime.t + (tm.s - LastStartClockTime.s), 0 );
  }
}

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

void PlayerInfo::EstimateMyPos()
{
  /* Takes me from previous time to time */
  if ( MyConf() && MyVelConf() )
    pos += vel;
}

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

void PlayerInfo::EstimateMyVel(Time time)
{
  if ( my_vel_time == time && vel_conf == CP_max_conf )
    return;
  
  /* Takes me from previous time to time */
  if ( SensedInfoKnown(time) ){
    float old_speed = vel.mod();
    if ( old_speed )
      vel = vel * GetMySensedSpeed(time)/old_speed; /* don't change the direction */
    else 
      vel = Polar2Vector( GetMySensedSpeed(time), MyBodyAng() );  /* use my direction */
    vel_conf = CP_max_conf;
  }
  else if ( vel_conf < CP_max_conf && SensedInfoKnown(time-1) ) {
    vel = Polar2Vector( GetMySensedSpeed(time-1)*SP_player_decay, MyBodyAng() );
    vel_conf = CP_conf_decay;
  }
  else if ( !MyVelConf() )
    return;
  else if ( my_vel_time == time-1 ){
    vel *= SP_player_decay;
    vel_conf *= CP_conf_decay;
  }
  else if ( my_vel_time > time-10 ){  /* missed up to 10 cycles */
    while ( my_vel_time < time && MyVelConf() ){
      vel *= SP_player_decay;
      vel_conf *= CP_conf_decay;
      ++my_vel_time;
    }
  }
  else
    my_error("Having trouble in vel update -- must have missed at least 10 cycles %.1f %.1f    %f",
	     (float)my_vel_time.t,(float)my_vel_time.s,MyVelConf());

  my_vel_time = time;
}

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

Vector PlayerInfo::NewVelFromDash(Vector old_vel, float dash_power)
{
   float effective_power = MyEffort() * dash_power;
   effective_power *= SP_dash_power_rate;
   Vector new_vel = old_vel +  Polar2Vector( effective_power, MyBodyAng() );

   if ( new_vel.mod() > SP_player_speed_max )
     new_vel *= ( SP_player_speed_max/new_vel.mod() );

   return new_vel;
}

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

void PlayerInfo::VerifyDash(float *dash_power)
{
  /* Check if recovery going down, or max_speed exceeded */