CS6601 Assignment 2: Two-Rook Isolation Tutorial

Introduction to Two-Rook Isolation

In the world of adversarial search, few games are as elegant and challenging as Isolation. The variant you'll tackle in CS6601 Assignment 2 – Two-Rook Isolation – pits two players, each controlling a rook, on an 8x8 board. The goal: be the last player able to move. This assignment is your gateway to mastering minimax with alpha-beta pruning, iterative deepening, and custom evaluation functions. As of May 27, 2026, these techniques remain foundational in AI for games like chess, Go, and even real-time strategy games like StarCraft II, where top AI agents use similar search algorithms.

This tutorial will guide you through the essential concepts without solving the assignment outright. By the end, you'll have a clear roadmap to implement a competitive agent that can hold its own in the Gradescope tournament.

Understanding the Game: Two-Rook Isolation

Two-Rook Isolation is played on a standard chessboard. Each player has one rook that moves like a chess rook – any number of squares horizontally or vertically, but cannot jump over blocked squares. After each move, the square the rook vacates becomes blocked (like a “hole”). The board shrinks as the game progresses, making the search space manageable for depth-limited search.

The key difference from standard Isolation is that each player controls only one piece, and both rooks can block each other's paths. This creates a fascinating adversarial dynamic reminiscent of battleship-style positioning or even the cat-and-mouse chase in popular games like Among Us, where players predict each other's moves.

Why This Assignment Matters

Adversarial search is not just for board games. It's used in AI for cybersecurity (simulating attacker-defender scenarios), autonomous driving (predicting other vehicles' moves), and financial trading (anticipating market moves). Mastering minimax and alpha-beta pruning gives you transferable skills for any turn-based strategy problem.

Core Algorithm: Minimax with Alpha-Beta Pruning

The heart of your CustomPlayer will be a minimax search that assumes both players play optimally. You'll implement alpha-beta pruning to cut off branches that cannot influence the final decision. This is crucial because the branching factor in Isolation can be large, especially early in the game.

Think of it like a March Madness bracket: you don't need to simulate every possible upset if you know a top seed will always beat a lower seed. Alpha-beta pruning lets you skip irrelevant parts of the game tree, saving time for deeper search.

Iterative Deepening

Because the assignment imposes a 1-second move limit, you'll use iterative deepening to search as deep as possible within the time constraint. Start with depth 1, then depth 2, etc., until time runs out. This ensures you always have a move ready, even if the full search is incomplete.

This technique is similar to how AI in real-time games like Dota 2 or Fortnite must make decisions under time pressure – they plan ahead but adapt to the ticking clock.

Designing a Winning Evaluation Function

Since you won't be able to search to terminal states (except near the end), you need a heuristic evaluation function to estimate the board's value. Common heuristics include:

Mobility difference: The number of legal moves your rook has minus the opponent's rook's moves. This is often the most effective.
Central control: Rooks near the center have more mobility. You can weight positions closer to the center higher.
Blocking potential: Forcing the opponent into a corner can be advantageous.

Your evaluation function should be fast because it's called millions of times during search. A simple linear combination of features often works well.

Consider the popularity of chess engines like Stockfish – they use complex evaluation functions with many terms. For this assignment, you don't need that complexity; a good mobility heuristic can beat a poorly tuned deep search.

Implementation Tips for CS6601 Assignment 2

Setting Up Your Environment

Follow the setup instructions carefully. Use conda to create a dedicated environment with Python 3.9. Install the required packages from requirements.txt. If you prefer an IDE like PyCharm, convert the notebook to a Python script using the provided helper:

bash helpers/notebook2script.py submission

Then work on submission.py. Remember to run all cells in the notebook at least once to understand the API.

Understanding the API

The CustomPlayer class expects you to implement get_move(). This method receives a game object and a time_left function. Use game.get_legal_moves() to get the list of moves, and game.forecast_move(move) to simulate a move without modifying the board.

Your search function should be recursive, with parameters for depth, alpha, beta, and maximizing player flag. A typical skeleton:

def minimax(game, depth, alpha, beta, maximizing_player):
    if depth == 0 or game.is_winner() or game.is_loser():
        return evaluate(game)
    if maximizing_player:
        value = -float('inf')
        for move in game.get_legal_moves():
            value = max(value, minimax(game.forecast_move(move), depth-1, alpha, beta, False))
            alpha = max(alpha, value)
            if alpha >= beta:
                break
        return value
    else:
        value = float('inf')
        for move in game.get_legal_moves():
            value = min(value, minimax(game.forecast_move(move), depth-1, alpha, beta, True))
            beta = min(beta, value)
            if alpha >= beta:
                break
        return value

Don't forget to sort moves by some heuristic (e.g., mobility) to improve pruning – this is a common optimization.

Avoiding Common Pitfalls

Not resetting alpha-beta correctly: Each recursive call should pass the current alpha and beta values.
Ignoring the time limit: Use iterative deepening and check time_left() after each depth iteration.
Overcomplicating the evaluation: Start with simple mobility difference and test.

Testing Your Agent

Use the provided tournament framework to test your agent against random or simple heuristic opponents. The assignment requires you to win a certain percentage of games against a baseline. Tune your evaluation function and search depth accordingly.

Think of this as training an AI for a game jam – iterate quickly, test often, and learn from losses. The Gradescope server will run 20 games (10 as first player, 10 as second) with random starting positions. Your agent must make each move within 1 second.

Connecting to Current Trends

Adversarial search is at the core of AlphaZero, which mastered chess, Go, and shogi through self-play. In 2026, similar techniques are used in AI for autonomous drone racing, where two drones compete to navigate a course while blocking each other. The principles you learn here – search, evaluation, and time management – are directly applicable.

Even in finance, high-frequency trading algorithms use adversarial search to anticipate other traders' moves. And in cybersecurity, intrusion detection systems model attacker behavior as a game.

Final Thoughts

CS6601 Assignment 2 is a challenging but rewarding deep dive into adversarial search. By implementing minimax with alpha-beta pruning, iterative deepening, and a custom evaluation function, you'll build an agent that can play Two-Rook Isolation at a high level. Remember to start simple, test frequently, and leverage the provided framework.

Good luck, and may your rooks always find open lanes!