Building a Find Four Game in Python: Master 2D Arrays and Error Handling

Introduction: Why Build a Find Four Game?

If you're taking COP3504c or just starting with Python, recreating a classic game like Find Four (brand name Connect Four) is an excellent way to solidify your understanding of 2D arrays, loops, and error handling. In this tutorial, we'll walk through building the core logic of a Find Four game, focusing on the data structures and functions you'll need. By the end, you'll have a solid foundation to complete your lab assignment. We'll also connect the concepts to real-world trends like AI game bots and gaming leaderboards to keep things interesting.

Setting Up the Board with 2D Arrays

The heart of Find Four is the game board, which is a 2D list (or array). In Python, we represent it as a list of lists. The first step is to create an empty board filled with '.' characters. The function get_initial_board(rows, columns) does exactly that. Think of it like setting up a spreadsheet for tracking esports tournament brackets — each cell holds a placeholder until a player makes a move.

def get_initial_board(rows, columns):
    board = []
    for r in range(rows):
        row = ['.'] * columns
        board.append(row)
    return board

Notice that we store rows from bottom to top: row 0 is the bottom. This matches the physical game where chips drop to the lowest available slot.

Printing the Board: Visual Feedback

Players need to see the board after each move. The print_board(board) function displays the board with row numbers (optional) and separators. In the lab, the output must match exactly, so pay attention to formatting. Here's a typical implementation:

def print_board(board):
    rows = len(board)
    cols = len(board[0])
    print('_' * (cols * 2 + 1))
    for r in range(rows-1, -1, -1):
        print('|', end='')
        for c in range(cols):
            print(board[r][c], end=' ')
        print('|')
    print('-' * (cols * 2 + 1))

This loops from the top row (rows-1) down to 0, printing each cell. The underscores and dashes create a classic game look.

Inserting Chips: Gravity Simulation

When a player selects a column, the chip must fall to the lowest empty row. The function insert_chip(board, column, chip) finds the next available row in that column and places the chip. It returns the row where the chip landed, which is crucial for win checking.

def insert_chip(board, column, chip):
    for row in range(len(board)):
        if board[row][column] == '.':
            board[row][column] = chip
            return row
    return -1  # column full (should not happen if validated)

This loop starts at row 0 (bottom) and goes upward. The first '.' encountered is the lowest empty spot. If the column is full, the function returns -1, but we'll handle that with error checking before calling this function.

Checking for a Win: Horizontal and Vertical

The is_win_state(chip, board, row, column) function checks if the last move resulted in a win. In this lab, only horizontal and vertical wins count (no diagonals). We check in four directions from the placed chip: left, right, down, and up. Here's a simplified version:

def is_win_state(chip, board, row, column):
    rows = len(board)
    cols = len(board[0])
    # Check horizontal
    count = 0
    for c in range(cols):
        if board[row][c] == chip:
            count += 1
            if count == 4:
                return True
        else:
            count = 0
    # Check vertical
    count = 0
    for r in range(rows):
        if board[r][column] == chip:
            count += 1
            if count == 4:
                return True
        else:
            count = 0
    return False

This function scans the entire row and column where the chip was placed. It's efficient because it only checks the row and column of the last move, not the whole board. This is similar to how AI algorithms in modern games optimize checks to keep gameplay smooth.

Checking for a Draw: Board Full

The function is_board_full(board) returns True if no '.' cells remain. This is straightforward:

def is_board_full(board):
    for row in board:
        if '.' in row:
            return False
    return True

If the board is full and no winner, the game ends in a draw.

Error Handling: Input Validation

A robust program must handle invalid input gracefully. The lab specifies that dimensions must be between 4 and 25, and column selections must be within range and not full. Use a loop to keep asking until valid input is received. For example:

while True:
    try:
        height = int(input("Enter height of board (rows): "))
        if height < 4:
            print("Error: height must be at least 4!")
        elif height > 25:
            print("Error: height can be at most 25!")
        else:
            break
    except ValueError:
        print("Error: not a number!")

This pattern is essential for any interactive program, whether it's a finance app asking for stock tickers or a school registration system.

Putting It All Together: Game Loop

The main game loop alternates between players, gets a column, inserts the chip, checks for win/draw, and displays the board. Here's a skeleton:

def play_game():
    rows = get_valid_dimension("Enter height of board (rows): ", "height")
    cols = get_valid_dimension("Enter width of board (columns): ", "width")
    board = get_initial_board(rows, cols)
    print_board(board)
    players = ['x', 'o']
    turn = 0
    while True:
        player = players[turn % 2]
        col = get_valid_column(board, cols, player)
        row = insert_chip(board, col, player)
        print_board(board)
        if is_win_state(player, board, row, col):
            print(f"Player {turn % 2 + 1} won the game!")
            break
        if is_board_full(board):
            print("Draw game! Players tied.")
            break
        turn += 1

This loop is similar to event loops in mobile app development or game engines, where you continuously process user input and update the state.

Testing and Debugging Tips

Test with small boards (4x4) and edge cases: full column, invalid column numbers, non-numeric input. Use print statements to verify board state. Remember that the lab's unit tests will check exact output, so match the formatting precisely.

Connecting to Trends: From Classic Games to AI Bots

Find Four is a classic, but its logic is the foundation for more advanced projects. For instance, you could extend it to create an AI opponent using minimax, similar to how AlphaGo mastered Go. Or you could add a leaderboard that tracks wins, like in competitive gaming platforms. Understanding 2D arrays and input validation is also crucial for data science (e.g., image pixels) and machine learning (e.g., grid-based neural networks).

Conclusion

By building this Find Four game, you've practiced essential programming skills: 2D arrays, loops, functions, and error handling. These concepts appear everywhere in tech, from web development to AI. Keep experimenting—maybe add diagonal wins, a computer player, or a graphical interface. Happy coding!