Question

Hello I am having trouble with a connectFour java program. this issue is in my findLocalWinner method, it declares a winner for horizontal wins, but not for vertical. if anyone can see what im doing wrong.

public class ConnectFour {

    /** Number of columns on the board. */
    public static final int COLUMNS = 7;

    /** Number of rows on the board. */
    public static final int ROWS = 6;
    
    /** Character for computer player's pieces */
    public static final char COMPUTER = 'X';

    /** Character for human player's pieces */
    public static final char HUMAN = 'O';

    /** Character for blank spaces. */
    public static final char NONE = '.';

    public static void dropPiece(char[][] board, char player, int column) {
        // TODO You have to write this.
    for(int i=0; i<ROWS;i++) {
//loop over all rows
    if (board[i][column] == NONE) {
// checks if spot on board is empty
    board[i][column] = player;  //if empty make that spot into player.
    break;

    }
    }
   
    }
    
    public static boolean isFull(char[][] board) {
        // TODO You have to write this.
    for (int j = 0; j < COLUMNS; j++ ) {
    if (board[ROWS-1][j] == NONE) {
    return false;
    }
    }  return true; // emplies board is full
   
   
    }
   
    public static boolean isLegalMove(char[][] board, int column) {
    
    for(int i=0; i<ROWS;i++) { //loop over all rows
     if (column >= 0 && column < COLUMNS) { //makes sure column is not out of bounds
      if (board[i][column] == NONE) {  //makes sure spot on board is empty
       return true;
    }
     }
        
    }
       return false;
    }
    public static char getOpposite(char player) {
        // TODO You have to write this.
    if (player == HUMAN) {        //if human just moved, its computers next move
    return COMPUTER;
    } 
    return HUMAN;        //if computer just moved its human next move
      
        }
    public static char findLocalWinner(char[][] board, int r, int c,
            int rowOffset, int colOffset) {
// TODO You have to write this.
        char player = board[r][c];               //player at that index
        //int counter = 0;
        if(player == NONE || c >= (COLUMNS - 3) ) {  //if player at r, c is NONE, also checks if win is possible
            player = NONE;
        //    return player;
        }
        
        if(rowOffset == 0 && colOffset != 0 && (c < COLUMNS || c > 0 )) {    //checks horizontal 
            for(int i = 0; i < 4 ; i++) {
                if(player == board[r][c+(1*colOffset)] && player == board[r][c+(2*colOffset)] &&player == board[r][c+(3*colOffset)]) { //checks for connect 4
                    return player;        //player is winner 
                }else {
                    player = NONE;        //no winner yet 
                }
            }
        }
        
        if(rowOffset != 0 && colOffset == 0 && (r < ROWS || r >0)) {        //checks vertical 
            for(int i = 0; i < 4 ; i++) {
                if(player == board[r+(1* rowOffset)][c] && player == board[r+(2*rowOffset)][c] &&player == board[r+(3*rowOffset)][c]) {
                    return player;
                }else {
                    player = NONE;
                }
            }
        if(rowOffset != 0 && colOffset != 0) {        //checks diagonal 
            for(int i = 0; i < 4 ; i++) {
                if(player == board[r+(1*rowOffset)][c+(1*colOffset)] && player == board[r+(2*rowOffset)][c+(2*colOffset)] &&player == board[r+(3*rowOffset)][c+(3*colOffset)]) {
                    return player;
                }else {
                    player = NONE;
                }
            }
        }
        }
            return player;
        }
    

    public static char findWinner(char[][] board) {
        // TODO You have to write this.
        // HINT: You should call the findLocalWinner method to help you

    char Winner = NONE;
    for(int row = 0; row < ROWS-3; row++) {  //loops over  rows
      for(int col = 0; col < COLUMNS-3; col++) {  //loops over  columns
    if(Winner  == NONE) {    //makes sure winner is NONE unless it finds human or comp
    Winner = findLocalWinner(board,row,col,0,1); //checks winner for horizontal
    }else if(Winner == NONE) {
    Winner = findLocalWinner(board,row,col,1,0); // checks winner for vertical 
    }else if(Winner == NONE) {
    Winner = findLocalWinner(board,row,col,1,1); // checks winner for diagonal 
    }else if(Winner == NONE) {
    Winner = findLocalWinner(board,row,col,-1,1); // checks winner for diagonal in downward direction
    }
    }
    }
        return Winner;
    }
    
    public static int bestMoveForComputer(char[][] board, int maxDepth) {
        // TODO You have to write this.
        // Hint: this will be similar to maxScoreForComputer
    int bestCol = -1;// (makes unbeatable AI)
    int bestResult = -20;
    for(int col= 0; col<COLUMNS; col++){
    if(isLegalMove(board,col)){
    dropPiece(board,COMPUTER,col);
    int result = minScoreForHuman(board,maxDepth,0);
        undoDrop(board,col);
    if(result >= bestResult){
    bestResult = result;
    bestCol = col;
    } 
    } 
    }
    return bestCol;
    }

    public static int maxScoreForComputer(char[][] board, int maxDepth, int depth) {
        // TODO You have to write this.
        // Hint: this will be similar to minScoreForHuman
    char winner = findWinner(board);
        if (winner == HUMAN) {
            
            return -10;
        } else if (winner == COMPUTER) {
           
            return 10;
        } else if (isFull(board) || (depth == maxDepth)) {
           
            return 0;
        } else {
            
            int bestResult = -20;

           
            for (int c = 0; c < COLUMNS; c++) {
                if (isLegalMove(board, c)) {
                    
                    dropPiece(board, COMPUTER, c);
                    
                    int result = maxScoreForComputer(board, maxDepth, depth +1);
                   
                    undoDrop(board, c);

                    if (result <= bestResult) {
                        
                        bestResult = result;
                    }
                }
            }
            return bestResult;
        }
    }
    public static int minScoreForHuman(char[][] board, int maxDepth, int depth) {
        char winner = findWinner(board);
        if (winner == COMPUTER) {
           
            return 10;
        } else if (winner == HUMAN) {
            
            return -10;
        } else if (isFull(board) || (depth == maxDepth)) {
            
            return 0;
        } else {
            
            int bestResult = 20;
            for (int c = 0; c < COLUMNS; c++) {
                if (isLegalMove(board, c)) {
                    
                    dropPiece(board, HUMAN, c);
                    
                    int result = maxScoreForComputer(board, maxDepth, depth + 1);
                    
                    undoDrop(board, c);

                    if (result <= bestResult) {
                       
                        bestResult = result;
                    }
                }
            }
            return bestResult;
        }
    }


    public static void undoDrop(char[][] board, int column) {
        // We'll start at the top and loop down the column until we
        // find a row with a piece in it. 
        int row = ROWS - 1;
        while(board[row][column] == NONE && row > 0) {
            row--;
        }

        // Set the top row that had a piece to empty again.
        board[row][column] = NONE;
    }

    /** Creates board array and starts game GUI. */
    public static void main(String[] args) {
        // create array for game board
        char[][] board = new char[ROWS][COLUMNS];
        // fill board with empty spaces
        for(int row = 0; row < ROWS; row++) {
            for (int col = 0; col < COLUMNS; col++) {
                board[row][col] = NONE;
            }
        }
      //ConnectFourGUI.showGUI(board, HUMAN, 5);
    }

}

Answer 1

        public static char findLocalWinner(char[][] board, int r, int c, int rowOffset, int colOffset) {
                // TODO You have to write this.
                char player = board[r][c]; // player at that index
                
// remove below condition completely
                // int counter = 0;
                // if (player == NONE || c >= (COLUMNS - 3)) { // if player at r, c is NONE, also checks if win is possible
                        // player = NONE;
                        // return player;
                }

                if (rowOffset == 0 && colOffset != 0 && (c < COLUMNS - 3 && c >= 0)) { // checks horizontal
                        for (int i = 0; i < 4; i++) {
                                if (player == board[r][c + (1 * colOffset)] && player == board[r][c + (2 * colOffset)]
                                                && player == board[r][c + (3 * colOffset)]) { // checks for connect 4
                                        return player; // player is winner
                                } else {
                                        player = NONE; // no winner yet
                                }
                        }
                }

                if (rowOffset != 0 && colOffset == 0 && (r < ROWS - 3 && r >= 0)) { // checks vertical
                        for (int i = 0; i < 4; i++) {
                                if (player == board[r + (1 * rowOffset)][c] && player == board[r + (2 * rowOffset)][c]
                                                && player == board[r + (3 * rowOffset)][c]) {
                                        return player;
                                } else {
                                        player = NONE;
                                }
                        }
                        if (rowOffset != 0 && colOffset != 0) { // checks diagonal
                                for (int i = 0; i < 4; i++) {
                                        if (player == board[r + (1 * rowOffset)][c + (1 * colOffset)]
                                                        && player == board[r + (2 * rowOffset)][c + (2 * colOffset)]
                                                        && player == board[r + (3 * rowOffset)][c + (3 * colOffset)]) {
                                                return player;
                                        } else {
                                                player = NONE;
                                        }
                                }
                        }
                }
                return player;
        }

highlighted my changes.. Code should now work fine for horizontal and vertical groups .