Question

Enhance and correct a Tic Tac Toe game. The game is intended to be played against a computer.

The object TicTacToeBoard is initialized to indicate if the computer is the player 1 or player 2. Your task is to allow turns between the player and computer and to determine if a winner exists.

Keyboard input implies using the Scanner object.

Review Section 7.7 in the textbook.

Ideally, do 1 task at a time and test the results. The tasks are arranged so that the previous work will help with your testing.

The TicTacToeBoard class uses a Character class which is a wrapper class for char. It allows for the value null. Thus, the board values can be ‘X’,’O’ or null.

Deliverables

Submit the modified and corrected TicTacToe class and TicTacToeBoard class.

Be sure to submit both files. If you neglect to include a file, you must email me the missing file before the due date.

The file GuiBoard.java does not need to be included as there are no required changes.

Program Assumptions

The TicTacToeBoard is instantiated with the Computer as player 2. This setting also determines who is ‘X’ and who is ‘O’. ‘X’ always goes first.

In the TicTacToe board will have null values in the ‘squares’ when started.

Program Requirements

1. In the TicTacToe class and TicTacToeBoard class, modify the comment headers to include your name and student ID and semester.
2. In the TicTacToe class, set the existing Long variable named securityCode with a value as defined below. The TicTacToeBoard instance will do these validations for you. The program must simply load a number that qualifies. You may need to test this several times to create a qualifying security code.
   1. securityCode must be a 16 digit number.
   2. securityCode must start with the digit 2.
   3. securityCode must not have sequential repeating digits.
      1. Such as ‘4’ in 271744.
   4. securityCode must not have sequential incrementing or decrementing digits. The next digit in the code cannot be 1 digit higher or 1 digit lower
      1. Such as ‘45’ in 27145.
      2. Such as ‘54’ in 27154.
   5. securityCode must contain every digit (0-9)
   6. Being that securityCode is a Long variable type, it must be defined with a following L.
      1. Long securityCode = 1234L.
   7. You may optionally define the security code value with underscores for readability.
      1. Long securityCode = 1234_4444_4444_4444L;
   8. Do not prompt for a security code, it must be coded inside the TicTacToe class.
3. Create a loop in the TicTacToe class to play the game. This will be referred to as the ‘main’ loop for this process.
   1. Create an int variable for row position. This declaration should be done only once and before the loop starts.
   2. Create an int variable for column position. This declaration should be done before the loop starts.
   3. Inside the loop, do the following tasks
      1. Display “Your Turn” and prompt to enter a row number (0-2) to place your TicTacToe square.
      2. Prompt to enter a column number (0-2) to place your TicTacToe square.
      3. Call the setValue() method of the TicTacToeBoard instance with the input given.
         1. setValue requires 2 parameters, Row and Column.
         2. setValue is a boolean value method. It generates a true or false result. If the setValue method returns false, it was unable to process the request. When this occurs, display “Try again” and resume the loop at the beginning.
      4. Call the method hasWinner() of the TicTacToeBoard instance.
         1. If hasWinner() returns true then
            1. Call the method theWinnerIs() of the TicTacToeBoard instance and display the value returned from theWinnerIs() method as in the example below.
            2. i.e. “The winner is X”
            3. Exit the loop.
      5. Call the method theComputersTurn() of the TicTacToeBoard instance. If this method returns a false value, display that “The computer has forfeited” and exit the loop.
      6. Do task iv again.
   4. After the loop is completed – display “Game over” from the main() method.

4. The method setValue() in the TicTacToeBoard class can be called with out of range numeric values and create a runtime error. Modify the setValue method so that it returns false if data passed is not in the range of possible values. (0 – 2).

5. The TicTacToeBoard class does not have a way to indicate that all entries are loaded. Create a public method named hasSquaresAvailable() in the the TicTacToeBoard class that will report true if there are available squares or false is the board is full. (Review the existing checkFirstPlay() method for a similar example.)
   1. Call this new method from the TicTacToe class inside the main loop.
      1. Do this before calling setValue().
      2. Do this before calling theComputersTurn().
      3. If there are no remaining spaces then:
         1. Display “No Available spaces”.
         2. Terminate the loop.

6. The TicTacToeBoard class currently only checks rows and columns.

          XXX           XOX

        OXO           XOO

        OOX           OOX

It does not check diagonal values.

         XXO         XOO

        OXX          XOX

        OOX         OXX

1. Create a private method inside the TicTacToeBoard class named checkForDiagonalWin that will check for a possible diagonal win. This method does not need internal loops. Study how the private method checkRowOrColumnForWinner() works to understand what to look for. Be careful to check for null values before doing other compares as this can result in a null pointer exception.

2. Call the method created above in step 8a from the theWinnerIs() method in the TicTacToeBoard class.

5 points Extra Credit – Change the valid input range from 0 -2 to 1-3 for the row and column indicators as part of the processing in the TicTacToe class. Do not change the setValue method in the TicTacToeBoard class. All other work must be completed to receive extra credit.

Answer 1

///////////////////////////////////////////////////////// TicTacToeBoard.java

import java.util.Random;

public class TicTacToeBoard {
private Character [][] board;// to hold all character
private Character player1;/// player 1
private Character player2;// player 2
  
public TicTacToeBoard(){
board=new Character[3][3];
  
// initialize board
for(int i=0;i<3;i++){
for(int j=0;j<3;j++){
this.board[i][j]=null;
}
}
  
// set computer as 2nd player
this.player1='X';
this.player2='O';
}
// display
  
void display(){
for(int i=0;i<3;i++){
System.out.print(" ");
  
for(int j=0;j<3;j++){
if(this.board[i][j]==null){
System.out.print(" ");
}
else{
System.out.print(this.board[i][j]);
}
  
  
if(j<2){
System.out.print(" | ");
}
}
  
if(i<2){
System.out.println("\n--------------");
}
System.out.println();
}
}
  
// set computer as first player
  
void setPlayer(){
this.player1='O';
this.player2='X';
}
  
  
// set for user move
  
boolean setValue(int i,int j){
boolean ret=false;
  
// out of the index list
  
if((i<0 || i>2) && (j<0 || j>2)){
ret=false;
}
else{
  
// if space available
  
if(hasSquaresAvailable(i,j)==true){
  
this.board[i][j]=this.player1;
  
ret=true;
}
}
  
return(ret);
}
  
  
// check space is occupied or not
public boolean hasSquaresAvailable(int i,int j){
return(this.board[i][j]==null);
}
  
// retun winner or not
  
public boolean hasWinner(){
  
   /* return win result */
  
   return(this.checkForDiagonalWin() || this.checkRowOrColumnForWinner());
  
}
  
  
// get winner name
public Character theWinnerIs(){
Character ret=' ';
int i=0;
  
   /* check each row */
   /* if each block in a row are same */
  
   for(i=0;i<3;i++){
if(this.board[i][0]!=null && this.board[i][0]==this.board[i][1] && this.board[i][1]==this.board[i][2]){
       ret=this.board[i][0];
       break;
}
   }
  
  
   /* check each col */
   /* if each block in a col are same */
  
   for(i=0;i<3;i++){
if(ret==' ' && this.board[0][i]!=null && this.board[0][i]==this.board[1][i] && this.board[1][i]==this.board[2][i]){
       ret=this.board[0][i];
       break;
}
   }
  
  
   /* if each block in 1st digonal are same */
  
   if(ret==' ' && this.board[0][0]!=null && this.board[0][0]==this.board[1][i] && this.board[1][1]==this.board[2][2]){
ret=this.board[0][0];
   }
  
   /* if each block in 2nd digonal are same */
  
   if(ret==' ' && this.board[2][0]!=null && this.board[2][0]==this.board[1][i] && this.board[1][1]==this.board[0][2]){
ret=this.board[2][0];
   }
  
   /* return win result */
  
return(ret);
}
  
  
// return computer turn
  
public boolean ComputersTurn(){
boolean ret=false;
  
// checking any space is available or not
for(int i=0;i<3;i++){
for(int j=0;j<3;j++){
if(this.board[i][j]==null){
ret=true;
break;
}
}
}
  
if(ret==false){
return(false);
}
  
// random turn
Random r=new Random();
  
  
int row=r.nextInt(3);
int col=r.nextInt(3);
  
// if move not available
while(this.hasSquaresAvailable(row,col)==false){
row=r.nextInt(3);
col=r.nextInt(3);
}
  
this.board[row][col]=this.player2;
  
return(true);
}
  
  
// if first player is user then return false;
// otherwise true
  
boolean checkFirstPlay(){
if(this.player1=='X'){
return(false);
}
else{
return(true);
}
}

  
// each digonal check
private boolean checkForDiagonalWin(){
boolean ret=false;
  
/* if each block in 1st digonal are same */
  
   if(this.board[0][0]!=null && this.board[0][0]==this.board[1][1] && this.board[1][1]==this.board[2][2]){
ret=true;
   }
  
   /* if each block in 2nd digonal are same */
  
   if(ret==false && this.board[2][0]!=null && this.board[2][0]==this.board[1][1] && this.board[1][1]==this.board[0][2]){
ret=true;
   }
  
return(ret);
}
  
  
// each row and column check for winner
private boolean checkRowOrColumnForWinner(){
boolean ret=false;
int i=0;
  
  
   /* check each row */
   /* if each block in a row are same */
  
   for(i=0;i<3;i++){
if(this.board[i][0]!=null && this.board[i][0]==this.board[i][1] && this.board[i][1]==this.board[i][2]){
       ret=true;
       break;
}
   }
  
  
   /* check each col */
   /* if each block in a col are same */
  
   for(i=0;i<3;i++){
if(ret==false && this.board[0][i]!=null && this.board[0][i]==this.board[1][i] && this.board[1][i]==this.board[2][i]){
       ret=true;
       break;
}
   }
  
return(ret);
}
}

////////////////////// TicTacToe.java

import java.util.Scanner;

public class TicTacToe {
private TicTacToeBoard board;
private long securityCode;
  
public TicTacToe(){
  
// sequrity code
  
this.securityCode=2910_3970_1482_7531L;
  
board=new TicTacToeBoard();
this.game();
}
  
void game(){
  
Scanner sc=new Scanner(System.in);
  
// user choice for compute first or not
  
System.out.print("Choose Player1 [C for computer /U for user] : ");
String inp=sc.next();
  
// user set for player
  
if(inp.charAt(0)=='C' || inp.charAt(0)=='c'){
this.board.setPlayer();
}
  
int row,col;
  
// check for computer is first player or not
  
if(this.board.checkFirstPlay()==true){
this.board.ComputersTurn();
}
  
  
  
while(true){
  
  
// display board
this.board.display();
  
// user move
System.out.print("\nYour Turn\nEnter Row Number [0-2] : ");
row=sc.nextInt();
  
System.out.print("Enter column Number [0-2] : ");
col=sc.nextInt();
  
// check user move is correct or not
  
// if ok , go to next step
if((row>=0 && row<=2) && (col>=0 && col<=2)){
  
  
// set user move
if(this.board.setValue(row, col)==true){
  
// check winner status for user
if(this.board.hasWinner()==true){
this.board.display();

System.out.println("\nThe Winner is "+this.board.theWinnerIs());
break;
}
else{
  
// if not win computer move
  
// if not move possible . break loop
if(this.board.ComputersTurn()==false){
this.board.display();
  
// if no computer move available break loop , and it is draw
  
System.out.println("\nNo Available spaces”");
System.out.println("The computer has forfeited");
break;
}
  
// move possible
else{
  
// check computer won the game or not
if(this.board.hasWinner()==true){
  
this.board.display();

System.out.println("\nThe Winner is "+this.board.theWinnerIs());
break;
}
}
}
}
  
// wrong bad user move
else{
System.out.println("Space is already occupied .Try Again.");
}
}
else{
System.out.println("Wrong Input , please choose correct inputs.");
}
  
  
}
  
System.out.println("Game Over.");
  
sc.close();
}
  
  
}

////////////////////////////////////  GuiBoard.java

public class GuiBoard {

public static void main(String[] args) {
TicTacToe t=new TicTacToe();
}
  
}