String C

/*
Beginning C, Third Edition
 By Ivor Horton
 ISBN: 1-59059-253-0
 Published: Apr 2004
 Publisher: apress
*/
#include 
#include 
#define SIZE 6  /* Board size - must be even */
/* Function prototypes */
void display(char board[][SIZE]);
int valid_moves(char board[][SIZE], int moves[][SIZE], char player); 
void make_move(char board[][SIZE], int row, int col, char player);  
void computer_move(char board[][SIZE], int moves[][SIZE], char player);  
int best_move(char board[][SIZE], int moves[][SIZE], char player);
int get_score(char board[][SIZE], char player);
void main()
{
  char board [SIZE][SIZE] = { 0 };  /* The board           */
  int moves[SIZE][SIZE] = { 0 };    /* Valid moves         */
  int row = 0;                      /* Board row index     */
  int col = 0;                      /* Board column index  */
  int no_of_games = 0;              /* Number of games     */
  int no_of_moves = 0;              /* Count of moves      */
  int invalid_moves = 0;            /* Invalid move count  */
  int comp_score = 0;               /* Computer score      */
  int user_score = 0;               /* Player score        */
  char y = 0;                       /* Column letter       */
  int x = 0;                        /* Row number          */
  char again = 0;                   /* Replay choice input */
  int player = 0;                   /* Player indicator    */
   printf("\nREVERSI\n\n");
  printf("You can go first on the first game, then we will take turns.\n");
  printf("   You will be white - (O)\n   I will be black   - (@).\n");
  printf("Select a square for your move by typing a digit for the row\n "
    "and a letter for the column with no spaces between.\n");
  printf("\nGood luck!  Press Enter to start.\n");
  scanf("%c", &again);
   /* Prompt for how to play - as before */
   /* The main game loop */
   do
   {
     /* On even games the player starts; */
     /* on odd games the computer starts */
     player = ++no_of_games % 2; 
     no_of_moves = 4;                /* Starts with four counters */
     /* Blank all the board squares */    
     for(row = 0; row < SIZE; row++)
       for(col = 0; col < SIZE; col++)
         board[row][col] = ' ';
     /* Place the initial four counters in the center */
     board[SIZE/2 - 1][SIZE/2 - 1] = board[SIZE/2][SIZE/2] = 'O';
     board[SIZE/2 - 1][SIZE/2] = board[SIZE/2][SIZE/2 - 1] = '@';
     /* The game play loop */
     do
     {
       display(board);             /* Display the board  */
       if(player++ % 2)
       { /*   It is the player's turn                    */
         if(valid_moves(board, moves, 'O'))
         {
           /* Read player moves until a valid move is entered */
           for(;;)
           {
             fflush(stdin);              /* Flush the keyboard buffer */
             printf("Please enter your move (row column): "); 
             scanf("%d%c", &x, &y);              /* Read input        */
             y = tolower(y) - 'a';         /* Convert to column index */
             x--;                          /* Convert to row index    */
             if( x>=0 && y>=0 && x             {
               make_move(board, x, y, 'O');
               no_of_moves++;              /* Increment move count */
               break;
             }
             else
               printf("Not a valid move, try again.\n");
           }
         }
         else                              /* No valid moves */
           if(++invalid_moves<2)
           {
             fflush(stdin);
             printf("\nYou have to pass, press return");
             scanf("%c", &again);
           }
           else
             printf("\nNeither of us can go, so the game is over.\n");
       }
       else
       { /* It is the computer's turn                    */
         if(valid_moves(board, moves, '@')) /* Check for valid moves */
         {
           invalid_moves = 0;               /* Reset invalid count   */
           computer_move(board, moves, '@');
           no_of_moves++;                   /* Increment move count  */
         }
         else
         {
           if(++invalid_moves<2)
             printf("\nI have to pass, your go\n"); /* No valid move */
           else
             printf("\nNeither of us can go, so the game is over.\n");
         }
       }
     }while(no_of_moves < SIZE*SIZE && invalid_moves<2);
     /* Game is over */
     display(board);  /* Show final board */
     /* Get final scores and display them */
     comp_score = user_score = 0; 
     for(row = 0; row < SIZE; row++)
       for(col = 0; col < SIZE; col++)
       {
         comp_score += board[row][col] == '@';
         user_score += board[row][col] == 'O';
       }
     printf("The final score is:\n");
     printf("Computer %d\n    User %d\n\n", comp_score, user_score);
     fflush(stdin);               /* Flush the input buffer */
     printf("Do you want to play again (y/n): ");
     scanf("%c", &again);         /* Get y or n             */
   }while(tolower(again) == 'y'); /* Go again on y          */
   printf("\nGoodbye\n"); 
}
/***********************************************
 * Function to display the board in it's       *
 * current state with row numbers and column   *
 * letters to identify squares.                *
 * Parameter is the board array.               *
 ***********************************************/
void display(char board[][SIZE])
{
   int row  = 0;          /* Row index      */
   int col = 0;           /* Column index   */
   char col_label = 'a';  /* Column label   */
   printf("\n ");         /* Start top line */
   for(col = 0 ; col     printf("   %c", col_label+col); /* Display the top line */
   printf("\n");                     /* End the top line     */
   /* Display the intermediate rows */  
   for(row = 0; row < SIZE; row++)
   {
     printf("  +");
     for(col = 0; col       printf("---+");
     printf("\n%2d|",row + 1); 
     for(col = 0; col       printf(" %c |", board[row][col]);  /* Display counters in row */
     printf("\n");    
   }
   printf("  +");                  /* Start the bottom line   */
   for(col = 0 ; col     printf("---+");               /* Display the bottom line */
   printf("\n");                   /* End the bottom  line    */
}
/***********************************************
/* Calculates which squares are valid moves    *
 * for player. Valid moves are recorded in the *
 * moves array - 1 indicates a valid move,     *
 * 0 indicates an invalid move.                *
 * First parameter is the board array          *
 * Second parameter is the moves array         *
 * Third parameter identifies the player       *
 * to make the move.                           *
 * Returns valid move count.                   *
 ***********************************************/
int valid_moves(char board[][SIZE], int moves[][SIZE], char player)
{
   int rowdelta = 0;     /* Row increment around a square    */
   int coldelta = 0;     /* Column increment around a square */
   int row = 0;          /* Row index                        */
   int col = 0;          /* Column index                     */
   int x = 0;            /* Row index when searching         */
   int y = 0;            /* Column index when searching      */
   int no_of_moves = 0;  /* Number of valid moves            */
   /* Set the opponent            */
   char opponent = (player == 'O')? '@' : 'O';    
   /* Initialize moves array to zero */
   for(row = 0; row < SIZE; row++)
     for(col = 0; col < SIZE; col++)
       moves[row][col] = 0;
   /* Find squares for valid moves.                           */
   /* A valid move must be on a blank square and must enclose */
   /* at least one opponent square between two player squares */
   for(row = 0; row < SIZE; row++)
     for(col = 0; col < SIZE; col++)
     {
       if(board[row][col] != ' ')   /* Is it a blank square?  */
         continue;                  /* No - so on to the next */
       /* Check all the squares around the blank square  */ 
       /* for the opponents counter                      */
       for(rowdelta = -1; rowdelta <= 1; rowdelta++)
         for(coldelta = -1; coldelta <= 1; coldelta++)
         { 
           /* Don't check outside the array, or the current square */
           if(row + rowdelta < 0 || row + rowdelta >= SIZE ||
              col + coldelta < 0 || col + coldelta >= SIZE || 
                                       (rowdelta==0 && coldelta==0))
             continue;
           /* Now check the square */
           if(board[row + rowdelta][col + coldelta] == opponent)
           {
             /* If we find the opponent, move in the delta direction  */
             /* over opponent counters searching for a player counter */
             x = row + rowdelta;                /* Move to          */
             y = col + coldelta;                /* opponent square  */
             /* Look for a player square in the delta direction */
             for(;;)
             {
               x += rowdelta;                  /* Go to next square */
               y += coldelta;                  /* in delta direction*/
               /* If we move outside the array, give up */
               if(x < 0 || x >= SIZE || y < 0 || y >= SIZE)
                 break;
               /* If we find a blank square, give up */ 
               if(board[x][y] == ' ')
                 break;
                /*  If the square has a player counter */
                /*  then we have a valid move          */
               if(board[x][y] == player)
               {
                 moves[row][col] = 1;   /* Mark as valid */
                 no_of_moves++;         /* Increase valid moves count */
                 break;                 /* Go check another square    */
               }
             } 
           } 
         }  
     }
   return no_of_moves; 
}
/************
 * Finds the best move for the computer. This is the move for      *
 * which the opponent's best possible move score is a minimum.     *
 * First parameter is the board array.                             *
 * Second parameter is the moves array containing valid moves.     *
 * Third parameter identifies the computer.                        *
 ************/
void computer_move(char board[][SIZE], int moves[][SIZE], char player)
{
   int row = 0;                          /* Row index               */
   int col = 0;                          /* Column index            */
   int best_row = 0;                     /* Best row index          */
   int best_col = 0;                     /* Best column index       */
   int i = 0;                            /* Loop index              */
   int j = 0;                            /* Loop index              */
   int new_score = 0;                    /* Score for current move  */
   int score = 100;                      /* Minimum opponent score  */
   char temp_board[SIZE][SIZE];          /* Local copy of board     */
   int temp_moves[SIZE][SIZE];           /* Local valid moves array */
   char opponent = (player == 'O')? '@' : 'O'; /* Identify opponent */
   /* Go through all valid moves */
   for(row = 0; row < SIZE; row++)
     for(col = 0; col < SIZE; col++)
     {
       if(moves[row][col] == 0)
         continue;
 
       /* First make copies of the board and moves arrays */
       for(i = 0; i < SIZE; i++)
         for(j = 0; j < SIZE; j++)
           temp_board[i][j] = board[i][j];
   
       /* Now make this move on the temporary board */
       make_move(temp_board, row, col, player); 
       /* find valid moves for the opponent after this move */
       valid_moves(temp_board, temp_moves, opponent);
       /* Now find the score for the opponents best move */
       new_score = best_move(temp_board, temp_moves, opponent);
       if(new_score       {                      /* Yes, so save this move */
         score = new_score;   /* Record new lowest opponent score */
         best_row = row;  /* Record best move row             */
         best_col = col;  /* and column                       */
       }
     }
   /* Make the best move */
   make_move(board, best_row, best_col, player); 
}
/************
 * Calculates the score for the current board position for the     *
 * player. player counters score +1, opponent counters score -1    *
 * First parameter is the board array                              *
 * Second parameter identifies the player                          *
 * Return value is the score.                                      *
 ************/
int get_score(char board[][SIZE], char player)
{
   int score = 0;      /* Score for current position */
   int row = 0;        /* Row index                  */    
   int col = 0;        /* Column index               */
   char opponent = player == 'O' ? '@' : 'O';  /* Identify opponent */
   /* Check all board squares */
   for(row = 0; row < SIZE; row++)
     for(col = 0; col < SIZE; col++)
   { 
     score -= board[row][col] == opponent; /* Decrement for opponent */
     score += board[row][col] == player;   /* Increment for player   */
   }
   return score;     
}
/************
 * Calculates the score for the best move out of the valid moves   *
 * for player in the current position.                             *
 * First parameter is the board array                              *
 * Second parameter is the moves array defining valid moves.       *
 * Third parameter identifies the player                           *
 * The score for the best move is returned                         *
 ************/
int best_move(char board[][SIZE], int moves[][SIZE], char player)
{
   int row = 0;     /* Row index    */
   int col = 0;     /* Column index */
   int i = 0;       /* Loop index   */
   int j = 0;       /* Loop index   */
   char opponent = player=='O'?'@':'O'; /* Identify opponent */
   char new_board[SIZE][SIZE] = { 0 };  /* Local copy of board    */
   int score = 0;                       /* Best score             */
   int new_score = 0;                   /* Score for current move */
   /* Check all valid moves to find the best */
   for(row = 0 ; row     for(col = 0 ; col     {
       if(!moves[row][col])             /* Not a valid move?      */
         continue;                      /* Go to the next         */
 
       /* Copy the board */
       for(i = 0 ; i         for(j = 0 ; j           new_board[i][j] = board[i][j];
       /* Make move on the board copy */
       make_move(new_board, row, col, player);  
       /* Get score for move */
       new_score = get_score(new_board, player);  
       if(score               score = new_score;  /* Yes, save it as best score  */
     }
   return score;                   /* Return best score           */
}
/*************
 * Makes a move. This places the counter on a square,and reverses   *
 * all the opponent's counters affected by the move.                *
 * First parameter is the board array.                              *
 * Second and third parameters are the row and column indices.      *
 * Fourth parameter identifies the player.                          *
 *************/
void make_move(char board[][SIZE], int row, int col, char player)
{
   int rowdelta = 0;                   /* Row increment              */
   int coldelta = 0;                   /* Column increment           */
   int x = 0;                          /* Row index for searching    */
   int y = 0;                          /* Column index for searching */
   char opponent = (player == 'O')? '@' : 'O';  /* Identify opponent */
   board[row][col] = player;           /* Place the player counter   */
   /* Check all the squares around this square */
   /* for the opponents counter                */
   for(rowdelta = -1; rowdelta <= 1; rowdelta++)
     for(coldelta = -1; coldelta <= 1; coldelta++)
     { 
       /* Don't check off the board, or the current square */
       if(row + rowdelta < 0 || row + rowdelta >= SIZE ||
          col + coldelta < 0 || col + coldelta >= SIZE || 
                               (rowdelta==0 && coldelta== 0))
         continue;
       /* Now check the square */
       if(board[row + rowdelta][col + coldelta] == opponent)
       {
         /* If we find the opponent, search in the same direction */
         /* for a player counter                                  */
         x = row + rowdelta;        /* Move to opponent */
         y = col + coldelta;        /* square           */
         for(;;)
         {
           x += rowdelta;           /* Move to the      */
           y += coldelta;           /* next square      */ 
           /* If we are off the board give up */
           if(x < 0 || x >= SIZE || y < 0 || y >= SIZE)
             break;
 
           /* If the square is blank give up */
           if(board[x][y] == ' ')
             break;
           /* If we find the player counter, go backwards from here */
           /* changing all the opponents counters to player         */
           if(board[x][y] == player)
           {
             while(board[x-=rowdelta][y-=coldelta]==opponent) /* Opponent? */
               board[x][y] = player;    /* Yes, change it */
             break;                     /* We are done    */
           } 
         }
       }
     }
}