Controller.java

import javafx.animation.TranslateTransition;
import javafx.application.Platform;
import javafx.fxml.FXML;
import javafx.fxml.Initializable;
import javafx.geometry.Point2D;
import javafx.scene.control.*;
import javafx.scene.layout.GridPane;
import javafx.scene.layout.Pane;
import javafx.scene.paint.Color;
import javafx.scene.shape.Circle;
import javafx.scene.shape.Rectangle;
import javafx.scene.shape.Shape;
import javafx.util.Duration;

import java.net.ConnectException;
import java.net.URL;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import java.util.ResourceBundle;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.sql.*;
import java.util.logging.Level;
import java.util.logging.Logger;

public class Controller implements Initializable {

    private static final int COLUMNS = 7;
    private static final int ROWS = 6;
    private static final int CIRCLE_DIAMETER = 80;
    private static final String discColor1 = "#0000cd";
    private static final String discColor2 = "#40e0d0";

    private static String PLAYER_ONE = "Player One";
    private static String PLAYER_TWO = "Player Two";

    private boolean isPlayerOneTurn = true;
    private boolean isPlayerTwoTurn = true;

    private Disc[][] insertedDiscsArray = new Disc[ROWS][COLUMNS]; // For Structural Changes: For the developers.

    @FXML
    public GridPane rootGridPane;

    @FXML
    public Pane insertedDiscsPane;

    @FXML
    public Label playerNameLabel;

    @FXML
    public Button setNames;

    @FXML
    public TextField playerOne;

    @FXML
    public TextField playerTwo;

    private boolean isAllowedToInsert = true; // Flag to avoid same color disc being added.

    public void createPlayground() {

        Shape rectangleWithHoles = createGameStructuralGrid();
        rootGridPane.add(rectangleWithHoles, 0, 1);

        List < Rectangle > rectangleList = createClickableColumns();

        for (Rectangle rectangle: rectangleList) {
            rootGridPane.add(rectangle, 0, 1);
        }
    }

    private Shape createGameStructuralGrid() {

        Shape rectangleWithHoles = new Rectangle((COLUMNS + 1) * CIRCLE_DIAMETER, (ROWS + 1) * CIRCLE_DIAMETER);

        for (int row = 0; row < ROWS; row++) {

            for (int col = 0; col < COLUMNS; col++) {
                Circle circle = new Circle();
                circle.setRadius(CIRCLE_DIAMETER / 2);
                circle.setCenterX(CIRCLE_DIAMETER / 2);
                circle.setCenterY(CIRCLE_DIAMETER / 2);
                circle.setSmooth(true);

                circle.setTranslateX(col * (CIRCLE_DIAMETER + 5) + CIRCLE_DIAMETER / 4);
                circle.setTranslateY(row * (CIRCLE_DIAMETER + 5) + CIRCLE_DIAMETER / 4);

                rectangleWithHoles = Shape.subtract(rectangleWithHoles, circle);
            }
        }

        rectangleWithHoles.setFill(Color.WHITE);

        return rectangleWithHoles;
    }

    private List < Rectangle > createClickableColumns() {

        List < Rectangle > rectangleList = new ArrayList < > ();

        for (int col = 0; col < COLUMNS; col++) {

            Rectangle rectangle = new Rectangle(CIRCLE_DIAMETER, (ROWS + 1) * CIRCLE_DIAMETER);
            rectangle.setFill(Color.TRANSPARENT);
            rectangle.setTranslateX(col * (CIRCLE_DIAMETER + 5) + CIRCLE_DIAMETER / 4);

            rectangle.setOnMouseEntered(event - > rectangle.setFill(Color.valueOf("#eeeeee26")));
            rectangle.setOnMouseExited(event - > rectangle.setFill(Color.TRANSPARENT));

            final int column = col;
            rectangle.setOnMouseClicked(event - > {
                if (isAllowedToInsert) {
                    isAllowedToInsert = false; // When disc is being dropped then no more disc will be inserted
                    insertDisc(new Disc(isPlayerOneTurn), column);
                }
            });

            rectangleList.add(rectangle);
        }

        return rectangleList;
    }

    private void insertDisc(Disc disc, int column) {

        int row = ROWS - 1;
        while (row >= 0) {

            if (getDiscIfPresent(row, column) == null)
                break;

            row--;
        }

        if (row < 0) // If it is full, we cannot insert anymore disc
            return;

        insertedDiscsArray[row][column] = disc; // For structural Changes: For developers
        insertedDiscsPane.getChildren().add(disc); // For Visual Changes : For Players

        disc.setTranslateX(column * (CIRCLE_DIAMETER + 5) + CIRCLE_DIAMETER / 4);

        int currentRow = row;
        TranslateTransition translateTransition = new TranslateTransition(Duration.seconds(0.5), disc);
        translateTransition.setToY(row * (CIRCLE_DIAMETER + 5) + CIRCLE_DIAMETER / 4);
        translateTransition.setOnFinished(event - > {

            isAllowedToInsert = true; // Finally, when disc is dropped allow next player to insert disc.
            if (gameEnded(currentRow, column)) {
                gameOver();
            }

            isPlayerOneTurn = !isPlayerOneTurn;
            playerNameLabel.setText(isPlayerOneTurn ? PLAYER_ONE : PLAYER_TWO);
        });

        translateTransition.play();
    }

    private boolean gameEnded(int row, int column) {

        List < Point2D > verticalPoints = IntStream.rangeClosed(row - 3, row + 3) // If, row = 3, column = 3, then row = 0,1,2,3,4,5,6
            .mapToObj(r - > new Point2D(r, column)) // 0,3  1,3  2,3  3,3  4,3  5,3  6,3 [ Just an example for better understanding ]
            .collect(Collectors.toList());

        List < Point2D > horizontalPoints = IntStream.rangeClosed(column - 3, column + 3)
            .mapToObj(col - > new Point2D(row, col))
            .collect(Collectors.toList());

        Point2D startPoint1 = new Point2D(row - 3, column + 3);
        List < Point2D > diagonal1Points = IntStream.rangeClosed(0, 6)
            .mapToObj(i - > startPoint1.add(i, -i))
            .collect(Collectors.toList());

        Point2D startPoint2 = new Point2D(row - 3, column - 3);
        List < Point2D > diagonal2Points = IntStream.rangeClosed(0, 6)
            .mapToObj(i - > startPoint2.add(i, i))
            .collect(Collectors.toList());

        boolean isEnded = checkCombinations(verticalPoints) || checkCombinations(horizontalPoints) ||
            checkCombinations(diagonal1Points) || checkCombinations(diagonal2Points);

        return isEnded;
    }

    private boolean checkCombinations(List < Point2D > points) {

        int chain = 0;

        for (Point2D point: points) {

            int rowIndexForArray = (int) point.getX();
            int columnIndexForArray = (int) point.getY();

            Disc disc = getDiscIfPresent(rowIndexForArray, columnIndexForArray);

            if (disc != null && disc.isPlayerOneMove == isPlayerOneTurn) { // if the last inserted Disc belongs to the current player

                chain++;
                if (chain == 4) {
                    return true;
                }
            } else {
                chain = 0;
            }
        }

        return false;
    }

    private Disc getDiscIfPresent(int row, int column) { // To prevent ArrayIndexOutOfBoundException

        if (row >= ROWS || row < 0 || column >= COLUMNS || column < 0) // If row or column index is invalid
            return null;

        return insertedDiscsArray[row][column];
    }

    private void gameOver() {
        //String winner = isPlayerOneTurn ? PLAYER_ONE : PLAYER_TWO;
        String winner = "NULL";
        if (isPlayerOneTurn == true) {
            winner = PLAYER_ONE;
            System.out.println("Winner is: " + winner);
        } else if (isPlayerTwoTurn == true) {
            winner = PLAYER_TWO;
            System.out.println("Winner is: " + winner);
        } else if (isPlayerOneTurn != true && isPlayerTwoTurn != true) {
            System.out.println("It is a Tie");
            System.out.print("Match is a draw saving data !");

        }

        if(winner == "NULL"){
            Alert alert = new Alert(Alert.AlertType.INFORMATION);
            alert.setTitle("Connect Four");
            alert.setHeaderText("The match was a draw!");
            saveDraw();
        }
        else {
            Alert alert = new Alert(Alert.AlertType.INFORMATION);
            alert.setTitle("Connect Four");
            alert.setHeaderText("The Winner is " + winner);
            winnerSave(winner);
        }

        alert.setContentText("Want to play again? ");

        ButtonType yesBtn = new ButtonType("Yes");
        ButtonType noBtn = new ButtonType("No, Exit");
        alert.getButtonTypes().setAll(yesBtn, noBtn);

        Platform.runLater(() - > { // Helps us to resolve IllegalStateException.

            Optional < ButtonType > btnClicked = alert.showAndWait();
            if (btnClicked.isPresent() && btnClicked.get() == yesBtn) {
                // ... user chose YES so RESET the game
                resetGame();
            } else {
                // ... user chose NO .. so Exit the Game
                Platform.exit();
                System.exit(0);
            }
        });
    }

    public void resetGame() {

        insertedDiscsPane.getChildren().clear(); // Remove all Inserted Disc from Pane

        for (int row = 0; row < insertedDiscsArray.length; row++) { // Structurally, Make all elements of insertedDiscsArray[][] to null
            for (int col = 0; col < insertedDiscsArray[row].length; col++) {
                insertedDiscsArray[row][col] = null;
            }
        }

        isPlayerOneTurn = true; // Let player start the game
        playerNameLabel.setText(PLAYER_ONE);

        createPlayground(); // Prepare a fresh playground
    }

    private static class Disc extends Circle {

        private final boolean isPlayerOneMove;

        public Disc(boolean isPlayerOneMove) {

            this.isPlayerOneMove = isPlayerOneMove;
            setRadius(CIRCLE_DIAMETER / 2);
            setFill(isPlayerOneMove ? Color.valueOf(discColor1) : Color.valueOf(discColor2));
            setCenterX(CIRCLE_DIAMETER / 2);
            setCenterY(CIRCLE_DIAMETER / 2);
        }
    }

    @Override
    public void initialize(URL location, ResourceBundle resources) {
        setNames.setOnAction(event -> {

            setPlayers();
        });

    }
    String player1 = null;
    String player2 = null;

    private void setPlayers() {
        player1 = playerOne.getText();
        PLAYER_ONE = player1;
        playerNameLabel.setText(PLAYER_ONE);
        player2 = playerTwo.getText();
        PLAYER_TWO = player2;
        try {
            Class.forName("com.mysql.jdbc.Driver");
            Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/connectfour", "root", "");
            String sql = "insert into userreg(player1,player2) values('" +
                player1 + "','" + player2 + "')";
            Statement stat = conn.createStatement();
            stat.execute(sql);
            stat.close();
            conn.close();
            System.out.println("Record saved");

        } catch (Exception ex) {
            System.out.println(ex.toString());
        }
    }

    // Function to get game ID from the database
    public int getGameID() {
        int gameID = 0;
        try {
            // Getting class from the lib
            Class.forName("com.mysql.jdbc.Driver");
            // Creating Connection With The Database
            Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/connectfour", "root", "");
            // Create Statement
            Statement stmt = conn.createStatement();
            // Setting Sql Query
            String querry = "select * from userreg ORDER BY ID DESC LIMIT 1";
            // Execute Statement to get results
            ResultSet rs = stmt.executeQuery(querry);
            if (rs.next()) {
                gameID = rs.getInt("ID");
            } else {
                System.out.println("Cannot Get Game ID!");
            }
        } catch (Exception ex) {
            Logger.getLogger(Controller.class.getName()).log(Level.SEVERE, null, ex);
        }
        System.out.println("Returning ID : " + gameID);
        return gameID;
    }
    public void winnerSave(String w) {
        try {
            Class.forName("com.mysql.jdbc.Driver");
            Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/connectfour", "root", "");
            String sql = "update userreg set winner='" +
                w + "' where ID='" + getGameID() + "'";
            Statement stat = conn.createStatement();
            stat.execute(sql);
            stat.close();
            conn.close();
            System.out.println("Record saved For Winner : " + w);

        } catch (Exception ex) {
            System.out.println(ex.toString());
        }
    }

    // Function to get List Of Winners
    public ResultSet getHistory() {
        ResultSet rs = null;
        try {
            // Getting class from the lib
            Class.forName("com.mysql.jdbc.Driver");
            // Creating Connection With The Database
            Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/connectfour", "root", "");
            // Create Statement
            Statement stmt = conn.createStatement();
            // Setting Sql Query
            String querry = "select * from userreg";
            // Execute Statement to get results
            rs = stmt.executeQuery(querry);
        } catch (Exception ex) {
            System.out.println("Error in getting history of players!");
            System.exit(1);
        }
        return rs;
    }

    //Function to store draw match
    public void saveDraw() {
        try {
            Class.forName("com.mysql.jdbc.Driver");
            Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/connectfour", "root", "");
            String sql = "update userreg set winner='" +
                "Draw" + "' where ID='" + getGameID() + "'";
            Statement stat = conn.createStatement();
            stat.execute(sql);
            stat.close();
            conn.close();
            System.out.println("Record saved For Draw : ");

        } catch (Exception ex) {
            System.out.println(ex.toString());
        }
    }
}