peterclient.c

足球机器人仿真组CMU97的源码

  char	     buf[MAXMESG];
  char       team, playmode[MAXMESG];

  n = receive_message(buf, MAXMESG, sock, &port, 0); 

  if(n == -1)
    my_error("n == -1 in initialize.  Why?");

  /************************************/
  /* First message from server used to*/
  /* set up client's memory and       */
  /* determine name of the log file   */
  /************************************/
  if ( !(strncmp(buf,"(init",4)) ) {
    /* It's an init msg */
    sscanf(buf,"(init %c %d %[^)]",&team, &number, playmode);
    Mem->Initialize(team,number,team_name,playmode,port);
  }
  else if ( !(strncmp(buf,"(reconnect",4)) ) {
    /* It's a reconnect msg */
    sscanf(buf,"(reconnect %c %[^)]",&team, playmode);
    printf("reconnecting to %d on side %c!\n",number,team);
    Mem->Initialize(team,number,team_name,playmode,port);
  }
  else /* Not an init message */
    return FALSE;

  /* Reset the port number to be used by this client */
  sock->serv_addr.sin_port = htons(port);

#if SAVE_LOG
  /**********************/
  /* Clear the log file */
  /**********************/
  sprintf(fpoutName,"%s%d-%c.log",team_name,number,team);
  fpout = fopen(fpoutName,"w");
#endif

#if SAVE_SOUND_LOG
  /**********************/
  /* Clear the log file */
  /**********************/
  sprintf(fpSoundoutName,"%s%d-%c-sounds.log",team_name,number,team);
  fpSoundout = fopen(fpSoundoutName,"w");
#endif

  return TRUE; /* successfully initialized */
}

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

void ProcessIncomingMessage(Socket *sock){

  char	     buf[MAXMESG];
  int        MessageCounter = 0, n, dummy_port; /* port doesn't matter at this point */
  static int counter = 0;
   
  /* keep receiving messages until the socket is empty (n==0) */
  while((n = receive_message(buf, MAXMESG, sock, &dummy_port, 0)) > 0){

    if (MessageCounter > 0){    /* not first time through while */

#if PRINT_MISSED_MSGS	      
      printf("Player %d-%c skipped a message at time %d\n",
	     Mem->MyNumber,Mem->MySide,Mem->CurrentTime);
#endif
#if SAVE_LOG
      fputs("   *** SKIPPED LAST MESSAGE ***\n",fpout);
#endif

    }
    MessageCounter++;

#if SAVE_LOG
    /***************************************/
    /* Store messages received to the file */
    /***************************************/
    fputs(buf, fpout);
    
    /** Every once in a while, store data **/
    if (counter%SAVE_FREQ == 0){
      fclose(fpout);
      fpout = fopen(fpoutName,"a");
    }
#endif

#if SAVE_SOUND_LOG
    /***************************************/
    /* Store messages received to the file */
    /***************************************/
    if (buf[1] == 'h') /* only hear messages */
      fputs(buf, fpSoundout);
    
    /** Every once in a while, store data **/
    if (counter%SAVE_SOUND_FREQ == 0){
      fclose(fpSoundout);
      fpSoundout = fopen(fpSoundoutName,"a");
    }
#endif

    counter++;

    ParseSensoryData(buf);      /* parse the sound OR sight           */

    /* Respond immediately if the delay is 0 */
    if ( Mem->HeardNewSound() && !Mem->CommunicateDelay ){
                                /* respond to sound                   */ 
      Communicate(0);           /* Could make this behavior-dependent */
      Mem->ClearSound();        /* Undo the sound bit                 */
    }

  }
  
  if(n == -1)
    my_error("n == -1.  Why?");
}

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

int ProcessKeyboardInput(Socket *sock, int *behavior, FILE *fpin){

  char	     buf[MAXMESG];

  fgets(buf, MAXMESG, fpin) ;
  sscanf(buf,"%d",behavior);

  if ( !(strncmp(buf,"q",1)) ){
    return FALSE;
    sscanf(buf,"(say (%s %d) %s)\n",Mem->MyTeamName,Mem->MyNumber,
	   BYE_MSG);
    if(send_message(buf, sock) == -1) my_error("send didn't work.  Why not");
  }
  if ( buf[0] == '(' ) {         /* Still take kbd input */
    if(send_message(buf, sock) == -1) ("send didn't work.  Why not? (2)");
  }
  else{
    switch(*behavior){
    case -8: Change_view(NORMAL_WIDTH,LOW_QUALITY); break;
    case -7: Change_view(NORMAL_WIDTH,HIGH_QUALITY); break;
    case FORGET: printf("Forget\n"); break;
    case RANDOM_INTERCEPT:  printf("Random Intercept\n"); break;
    case INTERCEPT:  printf("Intercept\n"); break;
    case SHOOT:  printf("Shoot\n"); break;
    case RANDOM_PASS:  printf("Random Pass\n"); break;
    case LEARNED_PASS:  printf("Learned Pass\n"); break;
    case COLLECT_PASS:  printf("Collect Pass\n"); break;
    case INTERCEPT_PASS:  printf("Intercept Pass\n"); break;
    case CHASE_AND_SHOOT: printf("ChaseAndShoot\n"); break;
    case DRIBBLE_AND_SHOOT: printf("DribbleAndShoot\n"); break;
    case DEFEND: printf("Defend\n"); break;
    case KAMRAM: printf("Kamram\n"); break;
    case GOALIE: printf("Goalie\n"); break;
    case CENTER_SWEEPER: printf("Sweeper\n"); break;
    case RIGHT_DEFENSE: printf("Right Defense\n"); break;
    case CENTER_DEFENSE: printf("Center Defense\n"); break;
    case LEFT_DEFENSE: printf("Left Defense\n"); break;
    case RIGHT_MIDFIELD: printf("Right Midfield\n"); break;
    case CENTER_MIDFIELD: printf("Center Midfield\n"); break;
    case LEFT_MIDFIELD: printf("Left Midfield\n"); break;
    case RIGHT_WING: printf("Right Wing\n"); break;
    case CENTER_FORWARD: printf("Center Forward\n"); break;
    case LEFT_WING: printf("Left Wing\n"); break;
    case START_SET_PLAY: printf("Start Set Play\n"); break;
    case RIGHT_MID_SET_PLAY: printf("Right Mid Set Play\n"); break;
    case LEFT_MID_SET_PLAY: printf("Left Mid Set Play\n"); break;
    case RIGHT_WINGER_SET_PLAY: printf("Right Winger Set Play\n"); break;
    case LEFT_WINGER_SET_PLAY: printf("Left Winger Set Play\n"); break;
    case FINISH_SET_PLAY: printf("Finish Set Play\n"); break;
    default: printf("Unknown behavior");
    }
  }
}

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

void message_loop(FILE* fpin, char* team_name, int unum, Socket *sock, int behavior, int my_score, int their_score)
{
    fd_set	readfds;
    int		in, max_fd, FIRST_TIME = TRUE;
    int         retrieve_message = FALSE;

    in = fileno(fpin) ;
    while(1){
	FD_ZERO(&readfds) ;
	FD_SET(sock->socketfd, &readfds) ;

#if TAKE_KBD_INPUT
	FD_SET(in, &readfds) ;
	max_fd = ((in > sock->socketfd) ? in : sock->socketfd) + 1 ;
#else
	max_fd = sock->socketfd + 1 ;
#endif
	/* Select waits for something on the socket before acting         */
	/* If I want to speed through the loop again, take this out       */
	/* For some reason I seem to at least need it with TAKE_KBD_INPUT */
	if ( !Mem->NewSight ) { /* If free to act, zip right to action */
	  if(select(max_fd, &readfds, 0, 0, 0) == -1){
	    perror("select") ;
	    break ;
	  }
	  retrieve_message = TRUE;
	}

	if (retrieve_message){

/***********************************************************/
/* Send incoming messages to file and parse them to memory */
/***********************************************************/
	
	  if( FD_ISSET(sock->socketfd, &readfds) ){
	    if ( FIRST_TIME ){
	      if ( ProcessInitializeMessage(sock,team_name,unum) ){
		Mem->OriginalBehavior = behavior;
		Mem->MyScore = my_score;
		Mem->TheirScore = their_score;
		//printf("my_score/theirs(2):   %d/%d\n",my_score,their_score);
		FIRST_TIME = FALSE;  /* Otherwise, keep waiting */
	      }
	    }
	    else
	      ProcessIncomingMessage(sock);
	  }
    
/***************************************************/
/* Take the input from keyboard to choose behavior */
/***************************************************/

#if TAKE_KBD_INPUT	
	  if( FD_ISSET(in, &readfds) ){
	    if ( !ProcessKeyboardInput(sock,&behavior,fpin) )
	      break;            /* Received a quit message */
	  }
#endif
	  
	  retrieve_message = FALSE;
	}
/***************************/
/* Do programmed behaviors */
/***************************/

	if ( Mem->NewSight ){  /* For now, only act after a see--not a hear */
	  Mem->NewSight = FALSE;    /* Undo the sight bit */
	  Mem->ClearAction();
	  DoBehavior(behavior);
	}

	if ( Mem->HeardNewSound() ){ 
	  int TimeSinceSound;
	  if ( Mem->PlayMode == BEFORE_KICK_OFF ){
	    /* time measured in terms of sights */
	    if ( Mem->StoppedClockTime >= Mem->GetNewSoundTime() ) 
	      TimeSinceSound = Mem->StoppedClockTime - Mem->GetNewSoundTime();
	    else 
	      TimeSinceSound = Mem->StoppedClockTime; /* just changed to this mode */
	  }
	  else
	    TimeSinceSound = Mem->CurrentTime - Mem->GetNewSoundTime();
	  /* priority to behaviors */
	  if ( (TimeSinceSound >= Mem->CommunicateDelay) )
	    if ( !Mem->NewSight || TimeSinceSound >= MAX_COMMUNICATE_DELAY ){
	      Communicate(0);         /* Could make this behavior-dependent */
	      Mem->ClearSound();      /* Undo the sound bit                 */
	    }
	}
    }
#if SAVE_LOG  
    fclose(fpout);  /* Only stores the data if client ended with "q" */
#endif

#if SAVE_SOUND_LOG  
    fclose(fpSoundout);  /* Only stores the data if client ended with "q" */
#endif
}


/*
 * socket の close
 *
 * 苞眶 :
 * sock : socket
 * 
 */

void close_connection(Socket sock)
{
    close(sock.socketfd) ;
}

/* for test */
#ifdef TEST
void main(int argc, char **argv)
{
    char *TeamName;
    int  unum = 0, my_score = 0, their_score = 0;
    int  arg_index = 1;
    char initMsg[MAXMESG];

    if(argc < 2) exit(1) ;

    GLOBAL_SOCK = init_connection(argv[arg_index++], DEFAULT_PORT_NUMBER) ;
    if(GLOBAL_sock->socketfd == -1)
	exit(1) ;

    if ( argv[arg_index][0] >= '0' && argv[arg_index][0] <= '9' ){
      /* It's a timing argument */
      SIMULATOR_STEP = atoi(argv[arg_index++]);
    }

    if (argc > 2) { 
      TeamName = strdup(argv[arg_index++]);
      sprintf(initMsg,"(init %s)\n", TeamName);   /*send the init msg*/
    }
    else 
      strcpy(TeamName, "CMUnited\n");

    if ( !strncmp(argv[0],"reconnect",8) ){
      if ( argc < arg_index+1 )
	my_error("Need a uniform number");
      unum = atoi(argv[arg_index++]);

      int score_arg_index = arg_index +1;

      if ( argc < score_arg_index+1 )
	printf("Assuming my score == 0\n");
      else
	my_score = atoi(argv[score_arg_index++]);

      if ( argc < score_arg_index+1 )
	printf("Assuming their score == 0\n");
      else
	their_score = atoi(argv[score_arg_index++]);

      sprintf(initMsg,"(reconnect %s %d)\n", TeamName, unum);   /*send the reconnect msg*/
    }

    if (send_message(initMsg, GLOBAL_sock) == -1)
      my_error("initMSG");

    int behavior = -2;
    if (argc > arg_index) {
      sscanf(argv[arg_index],"%d",&behavior);
    }

#if TAKE_KBD_INPUT 
    message_loop(stdin, TeamName, unum, GLOBAL_sock, behavior, my_score, their_score) ; 
#else
    FILE *fpin;
    fpin = fopen("blank-file","r");
    message_loop(fpin, TeamName, unum, GLOBAL_sock, behavior, my_score, their_score) ; 
    fclose(fpin);
#endif

    close_connection(GLOBAL_SOCK) ;
}
#endif /* TEST */