Connect4 RL | Gerard Calvo Bartra

A minimax-like algorithm for an AI agent to play the Connect4 game.

PROJECT

Connect4 RL

IMPACT AREAS

SERVICES

Python
NumPy

Challenge: Building an intelligent Connect4 opponent from scratch

Connect4, while appearing simple, is a complex strategic game with a vast search space. Creating an AI that can play at a competitive level requires implementing sophisticated game-playing algorithms and strategic evaluation functions.

The challenge was to develop a complete Connect4 gaming system that included:

A robust game engine that properly implements Connect4 rules and mechanics
An intelligent AI opponent using classical game-playing algorithms
A user-friendly graphical interface for human players
Adjustable difficulty levels to accommodate different skill levels
Efficient board evaluation and move generation systems

This summer project emerged from curiosity about game AI implementation and provided an opportunity to explore classical algorithms like minimax with alpha-beta pruning in a practical, interactive context.

Approach: Minimax algorithm with intelligent board evaluation

I implemented a classical game AI approach using the minimax algorithm with alpha-beta pruning, combined with a sophisticated board evaluation function. This approach is well-suited for Connect4's perfect information, zero-sum game structure.

The AI system consists of several key components:

Minimax search algorithm with configurable depth for different difficulty levels
Alpha-beta pruning for efficient tree search and reduced computation time
Advanced position evaluation function that assesses potential winning lines
Move ordering optimization with randomization to prevent predictable play
Real-time game state analysis and winner detection

The evaluation function goes beyond simple win detection to assess the strategic value of positions by counting potential four-in-a-row formations, giving the AI the ability to plan several moves ahead and recognize advantageous positions before they become winning moves.

Implementation: Modular architecture with Pygame interface

The implementation follows a clean, modular architecture with separate components for game logic, AI decision-making, and user interface. This separation allows for easy testing and modification of individual components.

The core architecture includes:

Connect4Game class: Core game logic, board state management, and rule enforcement
Connect4Pygame class: Visual interface using Pygame for rendering and user interaction
Game state management: Menu system, gameplay flow, and game-over handling
AI integration: Seamless integration of minimax algorithm with the game engine
Input handling: Mouse-based interaction for column selection and menu navigation

The AI implementation features a sophisticated minimax algorithm:

minimax_algorithm.py

def minimax(self, depth, alpha, beta, maximizingPlayer, player):
    winner = self.check_winner()
    
    # Shuffle columns to provide randomness
    rng = np.random.default_rng()
    columns = np.arange(self.columns)
    rng.shuffle(columns)
    
    if depth == 0 or winner is not None or self.is_full():
        if winner == player:
            return None, 100
        elif winner and winner != player:
            return None, -100
        else:
            return None, self.evaluate_position(player)
    
    if maximizingPlayer:
        maxEval = float('-inf')
        bestCol = None
        for col in columns:
            if self.board[0][col] == '.':
                # Make the move
                self.board, row = self.make_move(col, player)
                _, eval = self.minimax(depth - 1, alpha, beta, False, player)
                # Undo the move
                self.board[row][col] = '.'
                
                if eval > maxEval:
                    maxEval = eval
                    bestCol = col
                alpha = max(alpha, eval)
                if beta <= alpha:
                    break
        return bestCol, maxEval

The position evaluation function analyzes potential four-in-a-row formations across all directions (horizontal, vertical, and diagonal), giving the AI strategic insight beyond immediate winning moves.

Features: Complete gaming experience with adaptive difficulty

The Connect4 RL system provides a comprehensive gaming experience with several notable features designed to create an engaging and challenging opponent for human players.

Key features include:

Adjustable AI difficulty: Players can select difficulty levels from 1-10, corresponding to minimax search depth
Interactive GUI: Clean Pygame interface with visual board representation and smooth piece-dropping animations
Real-time gameplay: Immediate AI responses with strategic move calculation
Game state management: Complete menu system, game-over detection, and restart functionality
Strategic randomization: AI includes controlled randomness to prevent completely predictable play patterns
Visual feedback: Clear indication of game outcomes, player turns, and move validation

The difficulty scaling is particularly effective, with higher levels providing increasingly challenging opponents that can think several moves ahead and recognize complex strategic patterns.

The interface design prioritizes usability, with intuitive mouse-based controls and clear visual feedback that makes the game accessible to players of all skill levels.

Technical Details: Algorithm optimization and performance considerations

The implementation incorporates several technical optimizations to ensure responsive gameplay even at higher difficulty levels:

Alpha-beta pruning: Reduces search space by eliminating branches that cannot improve the final decision
Move ordering: Column shuffling provides randomization while maintaining strategic strength
Efficient board representation: 2D array structure enables fast move generation and evaluation
Optimized evaluation function: Strategic position assessment without expensive computation
Memory management: Proper move undoing prevents memory leaks during deep searches

The position evaluation function analyzes potential four-in-a-row formations by examining lines in all four directions (horizontal, vertical, and both diagonals). It assigns scores based on the number of player pieces in each potential line while checking for opponent blocking pieces.

Performance optimizations ensure that even at maximum difficulty (depth 10), the AI responds within reasonable time frames, making the game enjoyable rather than frustrating for human players.

Results: A challenging and engaging Connect4 opponent

The Connect4 RL system successfully creates a formidable opponent that provides appropriate challenge across different skill levels. The minimax implementation with alpha-beta pruning enables the AI to play strategically and recognize both offensive and defensive opportunities.

Key achievements include:

Strategic gameplay: AI demonstrates understanding of Connect4 strategy, including blocking opponent wins and setting up multiple threats
Scalable difficulty: The 10-level difficulty system provides appropriate challenge for beginners through expert players
Responsive performance: Even at high difficulty levels, move calculation remains fast enough for real-time play
Robust game engine: The underlying game logic correctly implements all Connect4 rules and edge cases
Polished user experience: Smooth interface with clear feedback and intuitive controls

The AI's strategic capabilities are particularly notable. At higher difficulty levels, it can recognize complex patterns such as forced wins several moves ahead, making it a genuinely challenging opponent even for experienced Connect4 players.

The inclusion of controlled randomization prevents the AI from being completely deterministic while maintaining its strategic strength, creating a more natural and varied playing experience.

Impact: Educational value and algorithmic insights

While developed as a summer curiosity project, Connect4 RL demonstrates several important concepts in game AI and algorithm implementation. The project serves as an excellent case study in how classical algorithms can be applied to create engaging interactive experiences.

The project illustrates key principles of game AI development:

Algorithm application: Practical implementation of minimax with alpha-beta pruning in a real game context
Evaluation function design: Creating strategic position assessment without game-specific knowledge
Performance optimization: Balancing computational depth with real-time responsiveness
User experience design: Making AI opponents challenging but not frustrating
Software architecture: Clean separation between game logic, AI, and interface components

The modular design makes the codebase educational for understanding game AI implementation, while the complete feature set demonstrates how to create polished interactive applications using Python and Pygame.

Future Enhancements: Potential improvements and extensions

The current implementation provides a solid foundation that could be extended in several interesting directions:

Machine learning integration: Training neural networks to improve position evaluation beyond hand-crafted functions
Opening book implementation: Adding databases of strong opening moves to enhance early-game play
Advanced search techniques: Implementing iterative deepening or transposition tables for improved performance
Multiplayer support: Adding network capabilities for online human vs. human or human vs. AI matches
Tournament mode: Creating AI vs. AI competitions to test different algorithms or parameter settings
Enhanced visualization: Adding move highlighting, strategy explanations, or game analysis features

The clean architecture makes such enhancements straightforward to implement, with well-defined interfaces between the game engine, AI system, and user interface components.

This project demonstrates how seemingly simple summer programming exercises can evolve into sophisticated explorations of algorithms, game theory, and software design—proving that curiosity-driven development often yields the most educational and satisfying results.

Technologies

This project was built with:

↗ Python

↗ NumPy

Connect4 RL | AI agent for Connect4