client.c

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

/*if ( 0 && Mem->MyCurrentFormationType() != FT_433 ){ my_error("?? pre-action %d\n"); dump_core("dump"); }*/

  /* Whether or not to wait between sending network packets is an interesting decsision.
     In versions of the server after 5.23, the server reads *all* commands off a socket at
     at every time step, so we could try to send all of our commands as soon as they are
     ready. However, on an ethernet, this can lead to lots of collisions and such, so it
     may degrade network performance
     To send everything without waiting, comment in this next line */
  //#define SEND_ALL_AT_ONCE
  
  /* the server now accepts multiple commands together  (after 5.23)
  if (0 && Mem->TooSoonForAnotherSend()) {
    Mem->LogAction2(200, "It's too soon to send another command. Waiting");
  } else {
  */
  
  if ( Mem->Action->valid() ) {
    send_action();
  }
#ifndef SEND_ALL_AT_ONCE
  else
#endif	
  if ( Mem->ResendNeeded() ){
    resend_last_action();
  }
#ifndef SEND_ALL_AT_ONCE
  else
#endif	
  if ( Mem->TurnNeck.valid() ){
    if ( Mem->TurnNeck.time < Mem->CurrentTime-1 ) my_error("old turn_neck");

    send_message( Mem->TurnNeck.command, Mem->sock );
    Mem->turn_necks++;
    Mem->TurnNeck.type = CMD_none; /* so it's no longer valid */
  }
#ifndef SEND_ALL_AT_ONCE
  else
#endif	
  if ( Mem->ChangeView.valid() ){
    if ( Mem->ChangeView.time < Mem->CurrentTime-1 ) my_error("old change_view");

    send_message( Mem->ChangeView.command, Mem->sock );
    Mem->ChangeView.type = CMD_none; /* so it's no longer valid */
  }
#ifndef SEND_ALL_AT_ONCE
  else
#endif	
  if ( Mem->SP_sense_body_step > Mem->SP_simulator_step )  {
    /* only if we won't get a sense_body each cycle by default */
    my_error("Sending sense_body");
    send_message(GLOBAL_sense_body_message,Mem->sock);  
  } 

  sigprocmask(SIG_UNBLOCK, &sigiomask, NULL);  
}




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

/* insert turn/dash/kick commands in commandlist */

void turn(AngleDeg ang) 
{
  NormalizeAngleDeg(&ang); 

  /* turn so that the actual turn is the desired turn */
  /* pos.rotate( ang/(1.0 + SP_inertia_moment * MySpeed()) ); */
  if ( Mem->MyVelConf() ) ang *= (1 + Mem->SP_inertia_moment * Mem->MySpeed());

  if ( ang > Mem->SP_max_moment ) ang = Mem->SP_max_moment;
  if ( ang < Mem->SP_min_moment ) ang = Mem->SP_min_moment;

  if (ang < .1 && ang > -.1) {
    Mem->Action->type = CMD_none;
    return;          /* No turn           */
  }

  Mem->Action->type = CMD_turn;
  Mem->Action->power = 0;
  Mem->Action->angle = ang;
  Mem->Action->time = Mem->CurrentTime;

  if (Mem->TurnNeck.time == Mem->CurrentTime){ /* Already did a turn_neck     */
    /* adjust as much as possible for the turn */
    Mem->TurnNeck.angle -= ang;
    if ( Mem->MyNeckRelAng() + Mem->TurnNeck.angle < Mem->SP_min_neck_angle )
      Mem->TurnNeck.angle = Mem->SP_min_neck_angle - Mem->MyNeckRelAng();
    if ( Mem->MyNeckRelAng() + Mem->TurnNeck.angle > Mem->SP_max_neck_angle )
      Mem->TurnNeck.angle = Mem->SP_max_neck_angle - Mem->MyNeckRelAng();
  }

  sprintf(Mem->Action->command,"(turn %.2f)", ang);
  Mem->LogAction3(150, "turn %f", ang);
}  

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

void dash(float power) 
{
  if ( Mem->PlayMode == PM_Before_Kick_Off ) return;

  if (power > Mem->SP_max_power) my_error("Can't dash that fast: %.1f",power); 
  if (power < Mem->SP_min_power) my_error("Can't dash that 'slow': %.1f",power);

  /* Factor for stamina--don't dash more than stamina or more than necessary to get you to max speed */
  Mem->VerifyDash(&power);

  if (fabs(power) < 1){
    Mem->Action->type = CMD_none;
    return;                         /* No dash           */
  }
  
  Mem->Action->type = CMD_dash;
  Mem->Action->power = power;
  Mem->Action->angle = 0;
  Mem->Action->time = Mem->CurrentTime;

  sprintf(Mem->Action->command, "(dash %.2f)", power);
  Mem->LogAction3(150, "dash %f", power);
}

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

void kick(float power, AngleDeg dir) 
{
  if ( !(Mem->BallKickable()) ) my_error("Can't kick a ball that's too far away");

  if ( Mem->PlayMode == PM_Before_Kick_Off ) return;

  if (power > Mem->SP_max_power) my_error("Can't kick that hard");
  if (power < 0 ) my_error("Can't kick < 0");
  NormalizeAngleDeg(&dir);

  Mem->Action->type = CMD_kick;
  Mem->Action->power = power;
  Mem->Action->angle = dir;
  Mem->Action->time = Mem->CurrentTime;

  sprintf(Mem->Action->command, "(kick %.2f %.2f)", power, dir);
  Mem->LogAction4(150, "kick %f %f", power, dir);
}

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

void goalie_catch(AngleDeg dir) 
{
  if ( !(Mem->BallCatchable()) ) my_error("Can't catch a ball that's too far away");
  if ( !Mem->CP_goalie ) my_error("Only goalies can catch");

  if ( Mem->PlayMode == PM_Before_Kick_Off ) return;

  NormalizeAngleDeg(&dir);

  Mem->Action->type = CMD_catch;
  Mem->Action->power = 0;
  Mem->Action->angle = dir;
  Mem->Action->time = Mem->CurrentTime;

  sprintf(Mem->Action->command, "(catch %.2f)", dir);
  Mem->LogAction3(150, "catch %f",  dir);
}


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

void move(float x, float y) 
{
  if ( ! (Mem->PlayMode == PM_Before_Kick_Off || 
	  (Mem->CP_goalie && Mem->PlayMode == PM_My_Goalie_Free_Kick)) )
    my_error("Can only move in before kickoff mode (or after goalie catch)");

  /* Perhaps here convert to a position on the field */
  if ( fabs(y) > Mem->SP_pitch_width/2 || x > 0 || x < -Mem->SP_pitch_length/2 )
    my_error("Must move to a place on the pitch");

  if ( Mem->PlayMode == PM_My_Goalie_Free_Kick && !Mem->OwnPenaltyArea.IsWithin(Vector(x,y)) )
    my_error("Must move to a place within penalty area");

  Mem->Action->type = CMD_move;
  Mem->Action->x = x;
  Mem->Action->y = y;
  Mem->Action->time =  Mem->CurrentTime;

  sprintf(Mem->Action->command, "(move %.2f %.2f)", x, y);
  Mem->LogAction4(150, "move %f %f", x, y);
}

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

void disconnect()
{
  Mem->Action->type = CMD_bye;
  Mem->Action->time =  Mem->CurrentTime;

  sprintf(Mem->Action->command, "(bye)");
}

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

void turn_neck(AngleDeg ang) 
{
  NormalizeAngleDeg(&ang); 

  if (ang == 0) {
    Mem->LogAction2(150, "Ignoring turn_neck 0");
    return;
  }  

  if ( ang > Mem->SP_max_neck_moment ) ang = Mem->SP_max_neck_moment;
  if ( ang < Mem->SP_min_neck_moment ) ang = Mem->SP_min_neck_moment;

  if ( Mem->MyNeckRelAng() + ang > Mem->SP_max_neck_angle ) {
    ang = Mem->SP_max_neck_angle - Mem->MyNeckRelAng();
    my_error("Can't turn neck that much");
  }
  
  if ( Mem->MyNeckRelAng() + ang < Mem->SP_min_neck_angle ) {
    ang = Mem->SP_min_neck_angle - Mem->MyNeckRelAng();
    my_error("Can't turn neck that little");
  }
  
  Mem->TurnNeck.type = CMD_turn_neck;
  Mem->TurnNeck.power = 0;
  Mem->TurnNeck.angle = ang;
  Mem->TurnNeck.time = Mem->CurrentTime;  

  sprintf(Mem->TurnNeck.command,"(turn_neck %.2f)", ang);
  Mem->LogAction3(150, "turn_neck %f", ang);
}

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

void change_view(Vqual qual, Vwidth width) 
{
  if ( qual==Mem->ViewQuality  && width==Mem->ViewWidth )
    return;  /* my_error("Nothing to change about view"); */

  Mem->ChangeView.type  = CMD_change_view;
  Mem->ChangeView.qual  = qual;
  Mem->ChangeView.width = width;
  Mem->ChangeView.time  = Mem->CurrentTime;

  char qual_string[10], width_string[10];
  switch (qual){
  case VQ_High: sprintf(qual_string,"high"); break;
  case VQ_Low:  sprintf(qual_string,"low");  break;
  }
  switch (width){
  case VW_Narrow: sprintf(width_string,"narrow"); break;
  case VW_Normal: sprintf(width_string,"normal"); break;
  case VW_Wide:   sprintf(width_string,"wide");   break;
  }

  sprintf(Mem->ChangeView.command, "(change_view %s %s)", width_string, qual_string);
  Mem->LogAction4(150, "change_view %s %s",  width_string, qual_string);
}

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

void send_action()
{	
  if ( !(Mem->Action->valid(Mem->CurrentTime)) )
    my_error("Old action %d %d",Mem->Action->time.t,Mem->Action->time.s);

  send_message(Mem->Action->command, Mem->sock);

  switch (Mem->Action->type){
  case CMD_kick:
    Mem->kicks++;
    Mem->GetBall()->set_past_kick(Mem->LastActionPower(), Mem->LastActionAngle(),
				  Mem->CurrentTime);
    break;
  case CMD_dash: Mem->dashes++; break;
  case CMD_turn: Mem->turns++;  break;
  default: ;
  }

  Command *tmp = Mem->LastAction;
  Mem->LastAction = Mem->Action;
  Mem->Action     = tmp;

  Mem->Action->type = CMD_none; /* So it's invalid */
  Mem->NewAction = TRUE;
}

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

void resend_last_action()
{
  if ( Mem->LastActionType() == Mem->ResendType ){
    my_stamp; printf("resending\n");
    send_message(Mem->LastAction->command, Mem->sock);

    switch (Mem->LastActionType()){
    case CMD_kick: Mem->kicks++;  break;
    case CMD_dash: Mem->dashes++; break;
    case CMD_turn: Mem->turns++;  break;
    default: ;
    }
  }
  else 
    my_error("last action isn't a %d",Mem->ResendType);

  Mem->RequestResend = FALSE;
}