Converting 3x3 tictactoe to 5x5 tictactoe

Question

I am trying to convert 3x3 tic tac toe algorithm to 5x5 tic tac toe algorithm. I searched a lot of algorithms but everytime I modified code computer starts from first row and continues from every column in that row.

This is the code that I found in web

public class TicTacToeAI {

 /* the board */
 private int board[][];
 /* empty */
 public static final int EMPTY = 0;
 /* player one */
 public static final int ONE = 1;
 /* player two */
    public static final int TWO = 2;

 public TicTacToeAI() {
  board = new int[3][3];
 }

 /* get the board value for position (i,j) */
 public int getBoardValue(int i,int j) {
  if(i < 0 || i >= 3) return EMPTY;
  if(j < 0 || j >= 3) return EMPTY;
  return board[i][j];
    }

 /* set the board value for position (i,j) */
 public void setBoardValue(int i,int j,int token) {
  if(i < 0 || i >= 3) return;
  if(j < 0 || j >= 3) return;
  board[i][j] = token;
    }

 /* calculate the winning move for current token */
 public int []nextWinningMove(int token) {

  for(int i=0;i<3;i++)
   for(int j=0;j<3;j++)
    if(getBoardValue(i, j)==EMPTY) {
     board[i][j] = token;
     boolean win = isWin(token);
     board[i][j] = EMPTY;
     if(win) return new int[]{i,j};
    }

  return null;
    }

    public int inverse(int token) {
  return token==ONE ? TWO : ONE;
 }

    /* calculate the best move for current token */
    public int []nextMove(int token) {

        /* lucky position in the center of board*/
        if(getBoardValue(1, 1)==EMPTY) return new int[]{1,1};

        /* if we can move on the next turn */
        int winMove[] = nextWinningMove(token);
        if(winMove!=null) return winMove;

        /* choose the move that prevent enemy to win */
        for(int i=0;i<3;i++)
            for(int j=0;j<3;j++)
                if(getBoardValue(i, j)==EMPTY)
                {
                    board[i][j] = token;
              boolean ok = nextWinningMove(inverse(token)) == null;
                    board[i][j] = EMPTY;
                    if(ok) return new int[]{i,j};
                }

        /* choose available move */
        for(int i=0;i<3;i++)
            for(int j=0;j<3;j++)
                if(getBoardValue(i, j)==EMPTY)
                    return new int[]{i,j};

        /* no move is available */
        return null;
    }

 /* determine if current token is win or not win */
 public boolean isWin(int token) {
      final int DI[]={-1,0,1,1};
      final int DJ[]={1,1,1,0};

      for(int i=0;i<3;i++)
           for(int j=0;j<3;j++) {

            /* we skip if the token in position(i,j) not equal current token */
            if(getBoardValue(i, j)!=token) continue;

                for(int k=0;k<4;k++) {
                     int ctr = 0;
                                 while(getBoardValue(i+DI[k]*ctr, j+DJ[k]*ctr)==token) ctr++;

                     if(ctr==3) return true;
            }
      }
      return false;
    }

}

And this is the code that I modified :

 /* the board */
 private int board[][];
 /* empty */
 public static final int EMPTY = 0;
 /* player one */
 public static final int ONE = 1;
 /* player two */
    public static final int TWO = 2;

 public TicTacToeAI() {
  board = new int[5][5];
 }

 /* get the board value for position (i,j) */
 public int getBoardValue(int i,int j) {
  if(i < 0 || i >= 5) return EMPTY;
  if(j < 0 || j >= 5) return EMPTY;
  return board[i][j];
    }

 /* set the board value for position (i,j) */
 public void setBoardValue(int i,int j,int token) {
  if(i < 0 || i >= 5) return;
  if(j < 0 || j >= 5) return;
  board[i][j] = token;
    }

 /* calculate the winning move for current token */
 public int []nextWinningMove(int token) {

  for(int i=0;i<5;i++)
   for(int j=0;j<5;j++)
    if(getBoardValue(i, j)==EMPTY) {
     board[i][j] = token;
     boolean win = isWin(token);
     board[i][j] = EMPTY;
     if(win) return new int[]{j,i};
    }

  return null;
    }

    public int inverse(int token) {
  return token==ONE ? TWO : ONE;
 }

    /* calculate the best move for current token */
    public int []nextMove(int token) {

        /* lucky position in the center of board*/
        if(getBoardValue(2, 2)==EMPTY) return new int[]{2,2};

        /* if we can move on the next turn */
       int winMove[] = nextWinningMove(token);
        if(winMove!=null) return winMove;

        /* choose the move that prevent enemy to win */
        for(int i=0;i<5;i++)
            for(int j=0;j<5;j++)
                if(getBoardValue(i, j)==EMPTY)
                {
                    board[i][j] = token;
              boolean ok = nextWinningMove(inverse(token)) == null;
                    board[i][j] = EMPTY;
                    if(ok) return new int[]{i,j};
                }

        for(int i=1;i<4;i++)
            for(int j=1;j<4;j++)
                if(getBoardValue(i, j)==EMPTY)
                    return new int[]{i,j};
                /* choose available move */
                else{
                    for(i=0;i<5;i++)
                        for(j=0;j<5;j++)
                            if(getBoardValue(i, j)==EMPTY)
                                return new int[]{i,j};

                }
        /* no move is available */
        return null;
    }

 /* determine if current token is win or not win */
public boolean isWin(int token) {
      final int DI[]={-1,0,1,1,1,0};
      final int DJ[]={1,1,1,0,-1,0};

      for(int i=0;i<5;i++)
           for(int j=0;j<5;j++) {

            // we skip if the token in position(i,j) not equal current token 
            if(getBoardValue(i, j)!=token) continue;

                for(int k=0;k<5;k++) {
                     int ctr = 0;
                                 while(getBoardValue(i+DI[k]*ctr, j+DJ[k]*ctr)==token) ctr++;

                     if(ctr==4) return true;
            }
      }
      return false;
    } 

}

Thanks for help

Answer 1

The strategy that the original program is using is only applicable to 3x3 tic-tac-toe — it does not look ahead beyond its own next move, so it cannot complete a five-move chain. (It can finish a chain if it somehow manages to get four in a row, and it'll block a row by the opponent, but it can't do anything more complex.) You will need to devise a new strategy to make this work.