Othello Game. First, to learn the rules of Othello and play online, you can go here:

Transcription

1 Othello Game As an example of implementing a computer player, let s use the game Othello as an example. We are not using Upthrust because that will be the topic for a homework assignment! First, to learn the rules of Othello and play online, you can go here: For our version we ll use an 8x8 array of char to represent the board. Our pieces will be X s and O s instead of black and white. Coordinate [0][0] is the lower left corner and [7][7] is the upper right corner, similar to how we represented the Upthrust board. void initboard(char board[][8]) for (int i = 0; i < 8; i++) for (int j = 0; j < 8; j++) board[i][j] = '.'; board[3][3] = 'X'; board[3][4] = 'O'; board[4][3] = 'O'; board[4][4] = 'X'; void displayboard(char board[][8]) for (int y = 7; y >= 0; y--) cout << y << " "; for (int x = 0; x < 8; x++) cout << " " << board[x][y]; cout << endl; cout << " " << endl; This displays the board in ASCII. It s not pretty but it s functional. Next let s implement a function to place a piece on the board. For now we ll assume the location we are placing the piece is a valid move. The move function takes as input the board, the XY coordinate to place the piece, and the piece we are placing (X or O).

2 void makemove(char board[][8], int x, int y, char piece) // Put the piece at x,y board[x][y] = piece; // Figure out the character of the opponent's piece char opponent = 'O'; if (piece == 'O') opponent = 'X'; // Check to the left if (checkflip(board, x - 1, y, -1, 0, piece, opponent)) flippieces(board, x - 1, y, -1, 0, piece, opponent); // Check to the right if (checkflip(board, x + 1, y, 1, 0, piece, opponent)) flippieces(board, x + 1, y, 1, 0, piece, opponent); // Check down if (checkflip(board, x, y-1, 0, -1, piece, opponent)) flippieces(board, x, y-1, 0, -1, piece, opponent); // Check up if (checkflip(board, x, y + 1, 0, 1, piece, opponent)) flippieces(board, x, y + 1, 0, 1, piece, opponent); // Check down-left if (checkflip(board, x-1, y - 1, -1, -1, piece, opponent)) flippieces(board, x-1, y - 1, -1, -1, piece, opponent); // Check down-right if (checkflip(board, x + 1, y - 1, 1, -1, piece, opponent)) flippieces(board, x + 1, y - 1, 1, -1, piece, opponent); // Check up-left if (checkflip(board, x - 1, y + 1, -1, 1, piece, opponent)) flippieces(board, x - 1, y + 1, -1, 1, piece, opponent); // Check up-right if (checkflip(board, x + 1, y + 1, 1, 1, piece, opponent)) flippieces(board, x + 1, y + 1, 1, 1, piece, opponent); This function uses two helper functions. checkflip looks in one of the 8 directions (left, right, up, down, upleft, upright, downleft, downright) to see if adjacent opponent pieces are sandwiched between our pieces. If so, it returns true. If not, it returns false. True means we should flip pieces in this direction. The -1, 0, and 1 control which direction we are looking. If we are looking to the right, then the x change is 1 but the y change is 0. If we are looking to the left, the x change is -1 and the y change is 0, etc. The function flippieces is similar to checkflip except it actually flips the pieces. // Checks a direction from x,y to see if we can make a move bool checkflip(char board[][8], int x, int y, int deltax, int deltay, char mypiece, char opponentpiece) if (board[x][y] == opponentpiece) while ((x >= 0) && (x < 8) && (y >= 0) && (y < 8)) x += deltax; y += deltay; if (board[x][y] == '.') // not consecutive return false; if (board[x][y] == mypiece)

3 // At least one piece we can flip // It is an opponent piece, just keep scanning in our direction return false; // Either no consecutive opponent pieces or hit the edge // Flips pieces in the given direction until we don't hit any more opponent pieces. // Assumes this is a valid direction to flip (we eventually hit one of our pieces). void flippieces(char board[][8], int x, int y, int deltax, int deltay, char mypiece, char opponentpiece) while (board[x][y] == opponentpiece) board[x][y] = mypiece; x += deltax; y += deltay; We can test this out with a main function that alternates making moves between X and O. We have to be careful to enter only valid moves! while (true) // Change later to detect game over makemove(board, x, y, curplayer); if (curplayer == 'X') curplayer = 'O'; curplayer = 'X'; Our next function is to determine whether a move is actually valid or not. A move is valid if the board location is unoccupied and we can flip pieces in any of the eight directions.

4 bool validmove(char board[][8], int x, int y, char piece) // Check that the coordinates are empty if (board[x][y]!= '.') return false; // Figure out the character of the opponent's piece char opponent = 'O'; if (piece == 'O') opponent = 'X'; // If we can flip in any direction, it is valid // Check to the left if (checkflip(board, x - 1, y, -1, 0, piece, opponent)) // Check to the right if (checkflip(board, x + 1, y, 1, 0, piece, opponent)) // Check down if (checkflip(board, x, y - 1, 0, -1, piece, opponent)) // Check up if (checkflip(board, x, y + 1, 0, 1, piece, opponent)) // Check down-left if (checkflip(board, x - 1, y - 1, -1, -1, piece, opponent)) // Check down-right if (checkflip(board, x + 1, y - 1, 1, -1, piece, opponent)) // Check up-left if (checkflip(board, x - 1, y + 1, -1, 1, piece, opponent)) // Check up-right if (checkflip(board, x + 1, y + 1, 1, 1, piece, opponent)) return false; // If we get here, we didn't find a valid flip direction We can check if the move is valid in main before trying to make the move. Also, there are some cases where no move is possible and we forfeit the turn. In this case we can enter -1 to skip to the next player. while (true) // Change later to detect game over

5 if (validmove(board, x, y, curplayer) (x == -1)) // Use -1 if no move possible if (x!= -1) makemove(board, x, y, curplayer); if (curplayer == 'X') curplayer = 'O'; curplayer = 'X'; cout << "Invalid move. Enter move again. " << endl; Let s make it detect if the game is over and compute the final score. The game is over when it is no longer possible for either player to move. There are cases where the game will end before all 64 squares are filled. To do this, let s make a function that fills in an array of valid moves for the current player. There can never be more than 60 valid moves (I am sure it is much less but 60 is an easy upper bound since there are 60 empty squares) so our strategy will be to make an X and Y array each of size 60 to hold the coordinates of valid moves, and then we ll make another variable to store how many valid moves we found. void getmovelist(char board[][8], int movex[], int movey[], int &nummoves, char piece) nummoves = 0; // Initially no moves found // Check each square of the board and if we can move there, remember the coords for (int x = 0; x < 8; x++) for (int y = 0; y < 8; y++) if (validmove(board, x, y, piece)) // remember coordinates movex[nummoves] = x; movey[nummoves] = y; nummoves++; // Increment number of moves found bool gameover(char board[][8]) int XMoveX[60], XMoveY[60], OMoveX[60], OMoveY[60]; int numxmoves, numomoves; getmovelist(board, XMoveX, XMoveY, numxmoves, 'X'); getmovelist(board, OMoveX, OMoveY, numomoves, 'O'); if ((numxmoves == 0) && (numomoves == 0)) return false;

6 int score(char board[][8], char piece) int total = 0; for (int x = 0; x < 8; x++) for (int y = 0; y < 8; y++) if (board[x][y] == piece) total++; return total; while (!gameover(board)) if (validmove(board, x, y, curplayer) (x == -1)) // Use -1 if no move possible if (x!= -1) makemove(board, x, y, curplayer); if (curplayer == 'X') curplayer = 'O'; curplayer = 'X'; cout << "Invalid move. Enter move again. " << endl; cout << endl << "The game is over!" << endl; cout << "X's score: " << score(board, 'X') << endl; cout << "O's score: " << score(board, 'O') << endl; Lastly, let s implement a random computer player. We can do this by picking a random move from the move list. void getrandommove(char board[][8], int &x, int &y, char piece) int movex[60], movey[60], nummoves;

7 getmovelist(board, movex, movey, nummoves, piece); if (nummoves == 0) x = -1; y = -1; int i = rand() % nummoves; x = movex[i]; y = movey[i]; srand(time(null)); while (!gameover(board)) if (curplayer == 'O') // Hard-code O to be random getrandommove(board, x, y, 'O'); Rest unchanged We hard-coded this to pick a random move for O but could also do this for X to have the computer play itself. OK that was a lot of code but we re in a place now where we can see a way to make the computer play better than random.