ConnectFourAI: An Intelligent Connect Four Game Engine Based on Adversarial Search

ConnectFourAI is a modular Connect Four game engine that fully implements an AI system from basic rules to advanced adversarial search algorithms. It includes random agents, rule-based agents, and Minimax agents with Alpha-Beta pruning, making it an excellent teaching case for understanding game tree search and competitive AI design. The project is maintained by Agrolax, derived from the CP468 Artificial Intelligence course at Wilfrid Laurier University, and its code is hosted on GitHub.

Original Author/Maintainer: Agrolax; Source Platform: GitHub; Original Title: ConnectFourAI: An interactive, search-driven Connect Four game engine and simulator powered by adversarial AI agents; Original Link: https://github.com/Agrolax/ConnectFourAI; Release Date: July 12, 2026; Course Affiliation: Wilfrid Laurier University CP468 Artificial Intelligence.

This project is a complete AI course project that implements the classic Connect Four game and multiple AI opponents. It serves both as a runnable simulator and a teaching codebase demonstrating the construction of adversarial search systems, presenting the evolutionary path of game AI design through three AI agents of different complexity levels.

Basic Rules

Connect Four is played on a 7×6 board. Two players take turns dropping pieces into columns (pieces fall to the lowest empty spot in the column). The first player to connect four pieces horizontally, vertically, or diagonally wins; if the board is full with no winner, it's a draw.

Engine Design

The game engine (engine.py) uses a 2D list to represent the 6-row ×7-column board state. Core functions include: generating valid moves (returning indices of columns where pieces can be dropped), gravity simulation (the apply_move method places pieces to the lowest empty spot), strict error handling (throwing ValueError for out-of-bounds or full columns), win detection (scanning for four-in-a-row directions), and deep state copying (clone() supports lookahead search).

The project implements three levels of AI agents:

1. RandomAgent: A baseline reference that randomly selects from valid moves, using a seeded random number generator to ensure reproducible results.
2. RuleBasedAgent: Hierarchical decision-making: first layer selects winning moves, second layer blocks the opponent's winning moves, third layer prioritizes central columns, fourth layer evaluates candidate positions based on the length of consecutive own pieces.
3. MinimaxAgent: Uses the Minimax algorithm with Alpha-Beta pruning, default search depth of 4; heuristic window evaluation (sliding to check 4-length windows and score based on the number of own/opponent pieces); endgame valuation (positive infinity for winning, negative infinity for losing).

Unit Tests

The project includes a complete unit test suite (tests/test_engine.py and tests/test_agents.py) covering win detection, draw judgment, illegal input handling, and agent decision correctness. Test command: python3 -m unittest discover -s tests.

Importance of Seeding

By specifying a pseudorandom number generator (PRNG) seed, experimental results are reproducible, battle outcomes are not affected by luck, and debugging and performance comparison are facilitated.

The project supports multiple run modes:

• Player vs Player: python3 main.py --mode player-vs-player
• Player vs Random AI: python3 main.py --mode player-vs-random
• Player vs Rule-Based AI: python3 main.py --mode player-vs-rulebased
• Player vs Minimax AI: python3 main.py --mode player-vs-minimax
• AI vs AI: python3 main.py --mode minimax-vs-random --seed 42 --delay 0.5

ConnectFourAI is an excellent AI teaching project that clearly demonstrates:

1. Hierarchical design of game AI (random → rule-based → search);
2. Core concepts of adversarial search (Minimax, Alpha-Beta pruning, state evaluation function);
3. Importance of reproducibility in AI research (seeding, unit testing);
4. Modular architecture (separation of engine, agents, and tests).

It is an ideal starting point for developers seeking to deeply understand game tree search. The code structure is clear, annotations are sufficient, and the problem scale is moderate, making it suitable as learning material.