{"id":37284,"date":"2023-10-31T21:04:50","date_gmt":"2023-10-31T21:04:50","guid":{"rendered":"https:\/\/www.baeldung.com\/java-connect-4-game"},"modified":"2023-10-31T21:04:50","modified_gmt":"2023-10-31T21:04:50","slug":"implement-connect-4-game-with-java","status":"publish","type":"post","link":"https:\/\/gamefootballmobileanimeiphone.com\/index.php\/2023\/10\/31\/implement-connect-4-game-with-java\/","title":{"rendered":"Implement Connect 4 Game with Java"},"content":{"rendered":"

1. Introduction<\/strong><\/h2>\n
<\/div>\n

In this article, we’re going to see how we can implement the game Connect 4<\/a> in Java. <\/strong>We’ll see what the game looks like and how it plays and then look into how we can implement those rules.<\/p>\n

2. What Is Connect 4?<\/strong><\/h2>\n
<\/div>\n

Before we can implement our game, we need to understand the rules of the game.<\/strong><\/p>\n

Connect 4 is a relatively simple game. Players take turns dropping pieces onto the top of one of a set of piles. After each turn, if any player’s pieces make a line of four in any straight-line direction – horizontal, vertical, or diagonal – then that player is the winner:<\/p>\n

\"\"<\/a><\/p>\n

If not, the next player gets to go instead. This then repeats until either one player wins or the game is unwinnable.<\/p>\n

Notably, players get free choice of which column to place their piece, but that piece must go on the top of the pile. They don’t get a free choice of which row within the column their piece goes.<\/p>\n

To build this as a computer game, we need to consider several different components: the game board itself, the ability for a player to place a token, and the ability to check if the game has been won.<\/strong> We’ll look at each of these in turn.<\/p>\n

3. Defining the Game Board<\/strong><\/h2>\n
<\/div>\n

Before we can play our game, we first need somewhere to play. This is the game board, which contains all the cells that players can play into and indicates where players have already placed their pieces.<\/strong><\/p>\n

We’ll start by writing an enumeration that represents the pieces that players can use in the game:<\/p>\n

public enum Piece {\r\n    PLAYER_1,\r\n    PLAYER_2\r\n}\r\n<\/code><\/pre>\n
This assumes that there are only two players in the game, which is typical for Connect 4.<\/p>\n
Now, we’ll create a class that represents the game board:<\/p>\n
public class GameBoard {\r\n    private final List<List<Piece>> columns;\r\n    private final int rows;\r\n    public GameBoard(int columns, int rows) {\r\n        this.rows = rows;\r\n        this.columns = new ArrayList<>();\r\n        for (int i = 0; i < columns; ++i) {\r\n            this.columns.add(new ArrayList<>());\r\n        }\r\n    }\r\n    public int getRows() {\r\n        return rows;\r\n    }\r\n    public int getColumns() {\r\n        return columns.size();\r\n    }\r\n}<\/code><\/pre>\n
Here, we’re representing the game board with a list of lists. Each of these lists represents an entire column in the game, and each entry in a list represents a piece within that column.<\/p>\n
Pieces must be stacked from the bottom, so we don’t need to account for gaps. Instead, all the gaps are at the top of the column above the inserted pieces. As such, we’re actually storing the pieces in the order they were added to the column.<\/strong><\/p>\n
Next, we’ll add a helper to get the piece that’s currently in any given cell on the board:<\/p>\n
public Piece getCell(int x, int y) {\r\n    assert(x >= 0 && x < getColumns());\r\n    assert(y >= 0 && y < getRows());\r\n    List<Piece> column = columns.get(x);\r\n    if (column.size() > y) {\r\n        return column.get(y);\r\n    } else {\r\n        return null;\r\n    }\r\n}\r\n<\/code><\/pre>\n
This takes an X-ordinate that starts from the first column and a Y-ordinate that starts from the bottom row. We’ll then return the correct Piece<\/em> for that cell or null<\/em> if there’s nothing in that cell yet.<\/p>\n
4. Playing Moves<\/strong><\/h2>\n
<\/div>\n
Now that we’ve got a game board, we need to be able to play moves on it. A player moves by adding their piece to the top of a given column.<\/strong> As such, we can do this by just adding a new method that takes the column and the player who’s making the move:<\/p>\n
public void move(int x, Piece player) {\r\n    assert(x >= 0 && x < getColumns());\r\n    List<Piece> column = columns.get(x);\r\n    if (column.size() >= this.rows) {\r\n        throw new IllegalArgumentException("That column is full");\r\n    }\r\n    column.add(player);\r\n}\r\n<\/code><\/pre>\n
We’ve also added an extra check in here. If the column in question already has too many pieces in it, then this will throw an exception instead of allowing the player to move.<\/p>\n
5. Checking for Winning Conditions<\/strong><\/h2>\n
<\/div>\n
Once a player has moved, the next step is to check if they’ve won. This means looking for anywhere on the board that we have four pieces from the same player in a horizontal, vertical, or diagonal line.<\/strong><\/p>\n
However, we can do better than this. There are certain facts that we know from how the game plays that allow us to streamline the search.<\/p>\n
Firstly, because the game ends when a winning move is played, only the player who’s just moved can win. This means we only need to check for lines of that player’s pieces.<\/p>\n
Secondly, the winning line must contain the piece that’s just been placed. This means we don’t need to search the entire board but only the subset that contains the played piece.<\/p>\n
Thirdly, we can ignore certain impossible cases because of the column nature of the game. For example, we can only have a vertical line if the newest piece is on at least row 4. Anything below that, and there can’t be four in a line.<\/p>\n
Ultimately, this means that we have the following sets to search for:<\/p>\n