Tic-Tac-Toe

Most people think Tic-Tac-Toe is trivial. A 3×3 grid, two symbols, done in 25 lines. But what happens when you need to detect a winner across 8 possible lines? When the game needs distinct states — you can't place a mark after someone wins? When players want to undo moves? When you add an AI opponent with three difficulty levels? That 25-line toy becomes a real design problem with real patterns hiding inside it.

We're going to build this game 7 times — each time adding ONE constraintA real-world requirement that forces your code to evolve. Each constraint is something the GAME needs, not a technical exercise. "Players need undo" is a constraint. "Use the Command pattern" is not — that's a solution you DISCOVER. that breaks your previous code. You'll feel the pain, discover the fix, and understand WHY the design exists. By Level 7, you'll have a complete, production-grade game engine — and a set of reusable thinking tools that work for any system.

Before we touch a single line of code, let's play an actual game of Tic-Tac-Toe. Not on a computer — on a piece of paper. Watch what happens step by step, and pay attention to every thing (noun) and every action (verb) you encounter. These become your classes, methods, and data types.

Every complex system starts with a laughably simple version. For Tic-Tac-Toe, that means: a board that holds marks, and a way to place them. That's it. No winner checking, no error handling, no nothing. The goal of Level 0 is to get something working — then let the next constraint break it.

Your Internal Monologue

"OK, simplest thing possible... A 2D array? char[3,3]? Or maybe a flat array of 9... No, 2D feels natural — row and column map directly to positions on the board."

"For the marks — should I use char with 'X' and 'O'? That works, but an enumA type with a fixed set of named values. enum Mark { None, X, O } means a cell can only ever be empty, X, or O — the compiler won't let you accidentally assign 'Z' or any other invalid value. is safer. Mark.X, Mark.O, Mark.None. The compiler catches mistakes instead of me."

"For turns... a boolean? _isXTurn — flip it after each move. No validation, no win checking — just the absolute minimum. I can feel this is incomplete, but that's the point."

// Flat array approach: 9 cells in a row
private readonly Mark[] _board = new Mark[9];

public void PlaceMark(int row, int col)
{
    int index = row * 3 + col;   // math to convert 2D → 1D
    _board[index] = CurrentMark;
    _isXTurn = !_isXTurn;
}

// Reading cell (1,2) means: _board[1 * 3 + 2] = _board[5]
// Not terrible, but you always need the row*3+col formula.

// 2D array approach: rows and columns are explicit
private readonly Mark[,] _board = new Mark[3, 3];

public void PlaceMark(int row, int col)
{
    _board[row, col] = CurrentMark;  // direct mapping!
    _isXTurn = !_isXTurn;
}

// Reading cell (1,2) means: _board[1, 2]
// Row and column are right there in the code.

Here's the complete Level 0 code. Read every line — there are only 15 of them.

public enum Mark { None, X, O }

public sealed class TicTacToeGame
{
    private readonly Mark[,] _board = new Mark[3, 3];
    private bool _isXTurn = true;

    public Mark CurrentMark => _isXTurn ? Mark.X : Mark.O;

    public void PlaceMark(int row, int col)
    {
        _board[row, col] = CurrentMark;
        _isXTurn = !_isXTurn;
    }
}

Let's walk through what each piece does:

• Mark enum — three possible values for any cell: empty (None), X, or O. Using an enum instead of raw characters means the compiler catches typos for us.
• _board — a 3×3 grid of Mark values. Every cell starts as Mark.None (the default for enums in C#).
• _isXTurn — a simple boolean toggle. true means it's X's turn, false means O's turn. Starts with X (convention: X always goes first).
• CurrentMark — a computed propertyA property that doesn't store a value — it calculates one on the fly. CurrentMark checks _isXTurn and returns Mark.X or Mark.O. No stored state to get out of sync. that reads _isXTurn and returns the right mark. No separate stored state to get out of sync.
• PlaceMark() — puts the current player's mark on the board, then flips the turn. Two lines. That's the entire game loop at this level.

15 lines. It works for a toy game. But can you spot what's missing? There's no win detection, no draw detection, no validation of moves, and players can overwrite each other's marks. We'll feel each of these pains in the coming levels.

Board Coordinate System

Turn Alternation — How _isXTurn Works

Growing Diagram — After Level 0

A game without an ending isn't really a game. Right now our code is just a grid with a toggle — there's no finish line, no winner announcement, no "game over." We need to teach the code how to see three in a row, and how to recognize when the board is full with no winner.

Your Internal Monologue

"8 win lines... I could write 8 separate if-statements. if (board[0,0] == board[0,1] && board[0,1] == board[0,2]) for the first row, then repeat for the other 7. That's explicit, but that's 30+ lines of nearly identical code."

"Or I could store the 8 line definitions as data — an array of three-cell tuplesA tuple groups multiple values together without creating a full class. In C#, (int Row, int Col) is a named tuple — lightweight and perfect for coordinate pairs. Three of these describe one winning line. — and loop through them. The loop is the SAME every time; only the DATA changes. That feels cleaner."

"And if somehow the board grew to 4×4 or 5×5, I'd just update the data, not rewrite the algorithm. ...Wait, YAGNI"You Aren't Gonna Need It" — a principle that says don't build features for hypothetical future requirements. But here, treating rules as data isn't extra work — it's actually LESS code than 8 if-statements. So it's good design, not premature engineering.. It's 3×3 right now. But treating rules as data is still the right instinct — it's actually less code anyway."

"For the result, I need more than just 'winner found.' The game could be in progress, X could win, O could win, or it could be a draw. That's four states. An enum GameResult with those four values."

The 8 Winning Lines

Every possible way to win — three of the same mark in a straight line. 3 rows + 3 columns + 2 diagonals = 8 total.

public Mark? CheckWinner()
{
    // Row 0
    if (_board[0,0] != Mark.None && _board[0,0] == _board[0,1] && _board[0,1] == _board[0,2])
        return _board[0,0];
    // Row 1
    if (_board[1,0] != Mark.None && _board[1,0] == _board[1,1] && _board[1,1] == _board[1,2])
        return _board[1,0];
    // Row 2
    if (_board[2,0] != Mark.None && _board[2,0] == _board[2,1] && _board[2,1] == _board[2,2])
        return _board[2,0];
    // ... 3 more for columns, 2 more for diagonals
    // Total: 8 nearly identical if-blocks. 30+ lines.
    return null;
}

public Mark? CheckWinner()
{
    // Check rows
    for (int r = 0; r < 3; r++)
        if (_board[r,0] != Mark.None && _board[r,0] == _board[r,1] && _board[r,1] == _board[r,2])
            return _board[r,0];

    // Check columns
    for (int c = 0; c < 3; c++)
        if (_board[0,c] != Mark.None && _board[0,c] == _board[1,c] && _board[1,c] == _board[2,c])
            return _board[0,c];

    // Diagonals — still special cases
    if (_board[0,0] != Mark.None && _board[0,0] == _board[1,1] && _board[1,1] == _board[2,2])
        return _board[0,0];
    if (_board[0,2] != Mark.None && _board[0,2] == _board[1,1] && _board[1,1] == _board[2,0])
        return _board[0,2];

    return null;
}

// Define the 8 winning lines as DATA
private static readonly (int R, int C)[][] WinLines =
[
    [(0,0),(0,1),(0,2)],  // row 0
    [(1,0),(1,1),(1,2)],  // row 1
    [(2,0),(2,1),(2,2)],  // row 2
    [(0,0),(1,0),(2,0)],  // col 0
    [(0,1),(1,1),(2,1)],  // col 1
    [(0,2),(1,2),(2,2)],  // col 2
    [(0,0),(1,1),(2,2)],  // diagonal ↘
    [(0,2),(1,1),(2,0)],  // diagonal ↙
];

// ONE loop checks them ALL
public Mark? CheckWinner()
{
    foreach (var line in WinLines)
    {
        var a = _board[line[0].R, line[0].C];
        if (a != Mark.None && a == _board[line[1].R, line[1].C]
                           && a == _board[line[2].R, line[2].C])
            return a;
    }
    return null;
}

Here's the complete Level 1 code. We add a WinLine recordA record in C# is an immutable data container — once created, its values can't change. Perfect for things like coordinate triples that represent fixed winning lines. Records also get free equality comparison, so two WinLines with the same coordinates are automatically equal., a GameResult enum, and a CheckResult() method that examines all 8 lines.

public enum Mark { None, X, O }

public enum GameResult { InProgress, XWins, OWins, Draw }

public record WinLine((int Row, int Col) A, (int Row, int Col) B, (int Row, int Col) C);

public sealed class TicTacToeGame
{
    private readonly Mark[,] _board = new Mark[3, 3];
    private bool _isXTurn = true;

    // All 8 winning lines — stored as data, not code
    private static readonly WinLine[] WinLines =
    [
        new((0,0),(0,1),(0,2)), new((1,0),(1,1),(1,2)), new((2,0),(2,1),(2,2)), // rows
        new((0,0),(1,0),(2,0)), new((0,1),(1,1),(2,1)), new((0,2),(1,2),(2,2)), // cols
        new((0,0),(1,1),(2,2)), new((0,2),(1,1),(2,0))                          // diags
    ];

    public Mark CurrentMark => _isXTurn ? Mark.X : Mark.O;

    public void PlaceMark(int row, int col)
    {
        _board[row, col] = CurrentMark;
        _isXTurn = !_isXTurn;
    }

    public GameResult CheckResult()
    {
        // Check each winning line
        foreach (var line in WinLines)
        {
            var a = _board[line.A.Row, line.A.Col];
            if (a != Mark.None
                && a == _board[line.B.Row, line.B.Col]
                && a == _board[line.C.Row, line.C.Col])
            {
                return a == Mark.X ? GameResult.XWins : GameResult.OWins;
            }
        }

        // No winner — check for draw (all cells filled)
        for (int r = 0; r < 3; r++)
            for (int c = 0; c < 3; c++)
                if (_board[r, c] == Mark.None)
                    return GameResult.InProgress;

        return GameResult.Draw;
    }
}

Let's walk through the new pieces:

• GameResult enum — four possible outcomes. The game is either still going (InProgress), someone won (XWins / OWins), or every cell is filled with no winner (Draw). These are the only possible states a Tic-Tac-Toe game can be in.
• WinLine record — holds three cell coordinates. Each instance represents one of the 8 ways to win. The record is immutableOnce a WinLine is created, you can't change its coordinates. This is intentional — winning lines are facts about the game's rules. They never change at runtime. Immutability makes your code safer because nothing can accidentally modify game rules mid-game. — winning rules don't change mid-game.
• WinLines array — all 8 winning patterns stored as data. The first three entries are rows, the next three are columns, the last two are diagonals. But the checking code doesn't care which is which — it treats them all the same.
• CheckResult() — iterates through all 8 lines. For each line, it reads the first cell (a). If a isn't empty AND all three cells match, we have a winner. If no line wins and no empty cells remain, it's a draw. Otherwise, the game continues.

Win Detection Algorithm Flow

Code vs. Data — Same Result, Different Maintainability

Both approaches produce identical results. The difference is in what happens when you need to change, debug, or extend them.

Growing Diagram — After Level 1

Your inner voice:

"I could add if (_state == GameState.InProgress) at the top of every method... but that means every method has state-checking boilerplate. And if I add a new state like 'Paused' for online play, I'd have to modify 5 methods. That violates OCPThe Open/Closed Principle says code should be open for extension but closed for modification. Adding new behavior should mean adding new code, not changing existing code.."

"Wait — the game's behavior depends on its state. Different state, different behavior for the same operation. That sounds like... the State patternThe State pattern lets an object change its behavior when its internal state changes. Instead of if-else chains checking state, each state becomes its own class with its own behavior. The object delegates to the current state object.. Each state becomes its own class. PlaceMark() in InProgressState does the real work. PlaceMark() in WonState returns an error. Adding 'Paused' means one new class, zero changes to existing ones."

What Would You Do?

Three developers, three ideas. Read all three, then see which one survives.

public GameResult PlaceMark(int row, int col)
{
    switch (_state)
    {
        case GameState.InProgress:
            _board[row, col] = _currentMark;
            ToggleTurn();
            return CheckResult();
        case GameState.Won:
            return GameResult.AlreadyOver;
        case GameState.Draw:
            return GameResult.AlreadyOver;
        case GameState.NotStarted:
            return GameResult.NotStarted;
        default:
            throw new InvalidOperationException();
    }
}

// Same switch block in Undo(), Reset(), Resign()...

private bool _isStarted = false;
private bool _isOver = false;
private bool _isDraw = false;
private bool _isResigned = false;

public GameResult PlaceMark(int row, int col)
{
    if (!_isStarted) return GameResult.NotStarted;
    if (_isOver) return GameResult.AlreadyOver;
    if (_isDraw) return GameResult.AlreadyOver;
    if (_isResigned) return GameResult.AlreadyOver;

    // ... actual logic buried under flag checks
}

// The game delegates to its current state
public GameResult PlaceMark(int row, int col)
    => _currentState.PlaceMark(this, row, col);

// InProgressState handles the real work
// WonState returns "game over"
// Adding PausedState = one new class, zero existing changes

The Solution

The State patternA behavioral design pattern where an object delegates its behavior to a state object. When the state changes, the behavior changes automatically. Each state is its own class implementing a common interface. gives every game mode its own class. The game itself doesn't contain any if-else logic — it just asks its current state "what should I do?"

public interface IGameState
{
    GameResult PlaceMark(TicTacToeGame game, int row, int col);
    bool CanPlaceMark { get; }
    string Status { get; }
}

public sealed class InProgressState : IGameState
{
    public bool CanPlaceMark => true;
    public string Status => "Game in progress";

    public GameResult PlaceMark(TicTacToeGame game, int row, int col)
    {
        // Place the mark and switch turns
        game.Board[row, col] = game.CurrentMark;
        game.ToggleTurn();

        // Check if this move ended the game
        var result = game.CheckResult();

        if (result == GameResult.XWins || result == GameResult.OWins)
            game.TransitionTo(new WonState(result));
        else if (result == GameResult.Draw)
            game.TransitionTo(new DrawState());

        return result;
    }
}

public sealed class WonState(GameResult result) : IGameState
{
    public bool CanPlaceMark => false;
    public string Status => $"{result} — game over";

    public GameResult PlaceMark(TicTacToeGame game, int row, int col)
        => result; // Silently reject — game is over
}

public sealed class DrawState : IGameState
{
    public bool CanPlaceMark => false;
    public string Status => "Draw — game over";

    public GameResult PlaceMark(TicTacToeGame game, int row, int col)
        => GameResult.Draw; // Board is full, nothing to do
}

public sealed class NotStartedState : IGameState
{
    public bool CanPlaceMark => false;
    public string Status => "Waiting to start";

    public GameResult PlaceMark(TicTacToeGame game, int row, int col)
        => GameResult.NotStarted; // Can't play before starting
}

public class TicTacToeGame
{
    private IGameState _currentState = new NotStartedState();

    public GameResult PlaceMark(int row, int col)
        => _currentState.PlaceMark(this, row, col);

    public bool CanPlaceMark => _currentState.CanPlaceMark;
    public string Status => _currentState.Status;

    public void TransitionTo(IGameState newState)
        => _currentState = newState;

    public void Start()
        => _currentState = new InProgressState();
}

Diagrams

State Machine — all the modes your game lives in

Every game starts in NotStarted, moves to InProgress when someone calls Start(), and then either ends in Won, Draw, or Resigned. Once it reaches a terminal state, it stays there — no going back.

Enum + Switch vs. State Pattern

On the left: every method contains a switch over all states. On the right: each state is its own class with a single clean implementation. Adding a new state (dashed box) is the real test — left requires modifying every method, right requires adding one file.

How States Block Invalid Operations

When PlaceMark() is called, the behavior depends entirely on which state object is active. InProgressState does the work, everything else rejects it.

Growing Diagram — Level 2

Our class diagram keeps growing. The game now holds a reference to IGameState (dashed = interface), and four concrete states implement it.

Before / After Your Brain

Your inner voice:

"I need to remember every move... A stack? Push on each move, pop on undo. But what IS a move? It's data: 'Player X placed mark at (1,2) on turn 3.' To undo: clear cell (1,2) and switch turns back."

"The move knows how to undo itself. That's the Command patternThe Command pattern turns a request (like "place a mark") into an object. That object stores all the data needed to execute the request AND reverse it. This is why undo/redo systems almost always use Commands — each action is a self-contained, reversible object.. Each move is a command object with Execute() and Undo(). The game history is just two stacks — an undo stack and a redo stack."

"When a new move happens: execute it and push to the undo stack. When the player hits undo: pop from the undo stack, reverse it, push to the redo stack. When they hit redo: pop from the redo stack, re-execute, push back to undo. Clean."

What Would You Do?

Two approaches to "remembering the past." One saves everything, the other saves just enough.

// Before every move, clone the entire board
var snapshot = (Mark[,])_board.Clone();
_history.Push(snapshot);

// Undo = restore the previous snapshot
_board = _history.Pop();

// Memory: 9 cells copied per move
// After 5 moves: 5 × 9 = 45 cell values stored

// Each move: 3 fields (who, row, col)
var move = new MoveCommand(Mark.X, 1, 2);
move.Execute(board);  // Place X at (1,2)
move.Undo(board);     // Clear (1,2)

// Memory: 3 fields per move
// After 5 moves: 5 × 3 = 15 values stored
// Replay: re-execute all commands from empty board

The Solution

The Command patternA behavioral design pattern that turns a request into a standalone object containing all information about the request. This lets you parameterize methods with different requests, delay or queue requests, and support undoable operations. turns every move into a self-contained object. The object knows what happened (which mark, where) and can reverse it. A GameHistory class manages two stacks to coordinate undo and redo.

public sealed record MoveCommand(Mark Mark, int Row, int Col)
{
    public void Execute(Board board)
        => board[Row, Col] = Mark;     // Place the mark

    public void Undo(Board board)
        => board[Row, Col] = Mark.None; // Clear the cell
}

public sealed class GameHistory
{
    private readonly Stack<MoveCommand> _undoStack = new();
    private readonly Stack<MoveCommand> _redoStack = new();

    public void Execute(MoveCommand command, Board board)
    {
        command.Execute(board);
        _undoStack.Push(command);
        _redoStack.Clear(); // New move invalidates redo history
    }

    public MoveCommand? Undo(Board board)
    {
        if (_undoStack.Count == 0) return null;

        var command = _undoStack.Pop();
        command.Undo(board);
        _redoStack.Push(command);
        return command;
    }

    public MoveCommand? Redo(Board board)
    {
        if (_redoStack.Count == 0) return null;

        var command = _redoStack.Pop();
        command.Execute(board);
        _undoStack.Push(command);
        return command;
    }

    public IReadOnlyList<MoveCommand> GetHistory()
        => _undoStack.Reverse().ToList();
}

Let's walk through what happens step by step:

• Execute: Run the command's Execute() on the board, then push it onto the undo stack. Crucially, clear the redo stack — because making a new move after undoing means the old "future" is no longer valid.
• Undo: Pop the most recent command from the undo stack, call its Undo() to reverse the effect, then push it onto the redo stack (so the player can redo it if they change their mind).
• Redo: Pop from the redo stack, re-execute it, push it back to the undo stack. It's like the move never left.
• GetHistory: Returns all executed moves in order — perfect for replaying the game from scratch or saving to a file.

Diagrams

How the Two Stacks Work Together

Think of two stacks sitting side by side. Every action moves a command between them. New moves go to the undo stack. Undo pops from undo and pushes to redo. Redo pops from redo and pushes back to undo.

Replay from History — a filmstrip of moves

Because each move is a command, you can replay an entire game by starting with an empty board and re-executing each command in order. This is how game replays work in chess apps and drawing programs.

Memory: Snapshots vs. Commands

Here's why commands win as systems grow. Snapshots save the entire state every time. Commands save only the delta — what changed.

Growing Diagram — Level 3

Two new pieces join our system: MoveCommand (an immutable record that knows how to execute and undo itself) and GameHistory (the stack manager that coordinates undo and redo).

Before / After Your Brain

Your inner voice:

"I need different ways to pick a move. A human picks by typing. A dumb AI picks randomly. A smart AI uses some algorithm. But the game doesn't care how the move is chosen — it just needs a row and a column."

"That's the key insight — the game wants a move, and different strategies produce that move in different ways. If I hide the 'how' behind an interface, the game just calls GetMove() and doesn't care whether a human typed it or an AI computed it."

"That's the Strategy patternThe Strategy pattern defines a family of algorithms, puts each one in its own class, and makes them interchangeable. The caller picks which strategy to use, but the code that uses the strategy doesn't change. Think of it like choosing a route on a GPS — fastest, shortest, or scenic — the GPS app doesn't care which algorithm you picked.. Each way of picking a move becomes its own class. The game holds a reference to the current strategy. Swapping from random AI to minimax AI means changing which strategy object is assigned — one line."

What Would You Do?

Three developers, three ideas for adding AI. One survives the "add a new difficulty" test.

// Inside the game loop
if (isComputerTurn)
{
    // AI logic lives right here in the game loop
    var emptyCells = board.GetEmptyCells();
    var random = new Random();
    var pick = emptyCells[random.Next(emptyCells.Count)];
    PlaceMark(pick.Row, pick.Col);
}
else
{
    // Human input
    var (row, col) = ReadFromConsole();
    PlaceMark(row, col);
}

public (int Row, int Col) GetAiMove(Difficulty level)
{
    if (level == Difficulty.Easy)
    {
        // Random pick
        return RandomEmptyCell();
    }
    else if (level == Difficulty.Medium)
    {
        // Win if possible, else random
        return TryWinOrRandom();
    }
    else if (level == Difficulty.Hard)
    {
        // Full minimax search
        return Minimax(board, depth: 0, isMaximizing: true);
    }
    throw new ArgumentException("Unknown difficulty");
}

// The game doesn't know WHO is playing — just asks for a move
var move = _currentPlayer.Strategy.GetMove(board);
PlaceMark(move.Row, move.Col);

// Human? Reads from console.
// Easy AI? Random empty cell.
// Hard AI? Minimax algorithm.
// All implement IPlayerStrategy.GetMove()

The Solution

The Strategy patternA behavioral design pattern that lets you define a family of algorithms, put each in its own class, and make them interchangeable at runtime. The object using the algorithm doesn't know or care which strategy it's running. separates "how a move is chosen" from "what happens when a move is made." The game asks for a move. The strategy delivers one. That's the entire contract.

public interface IPlayerStrategy
{
    (int Row, int Col) GetMove(Board board);
}

public sealed class HumanStrategy : IPlayerStrategy
{
    public (int Row, int Col) GetMove(Board board)
    {
        Console.Write("Enter row and column (e.g. 1 2): ");
        var parts = Console.ReadLine()!.Split(' ');
        return (int.Parse(parts[0]), int.Parse(parts[1]));
    }
}

public sealed class RandomStrategy : IPlayerStrategy
{
    private readonly Random _rng = new();

    public (int Row, int Col) GetMove(Board board)
    {
        var empty = board.GetEmptyCells();
        return empty[_rng.Next(empty.Count)];
    }
}

public sealed class MinimaxStrategy(Mark aiMark) : IPlayerStrategy
{
    public (int Row, int Col) GetMove(Board board)
    {
        var (_, move) = Minimax(board, isMaximizing: true);
        return move;
    }

    private (int Score, (int Row, int Col) Move) Minimax(
        Board board, bool isMaximizing)
    {
        // Base cases: someone won or board is full
        if (board.HasWinner(aiMark)) return (+10, (-1, -1));
        if (board.HasWinner(Opponent())) return (-10, (-1, -1));
        if (board.IsFull()) return (0, (-1, -1));

        var bestScore = isMaximizing ? int.MinValue : int.MaxValue;
        var bestMove = (-1, -1);

        foreach (var cell in board.GetEmptyCells())
        {
            // Try this move
            board[cell.Row, cell.Col] = isMaximizing ? aiMark : Opponent();
            var (score, _) = Minimax(board, !isMaximizing);
            board[cell.Row, cell.Col] = Mark.None; // Undo

            if (isMaximizing ? score > bestScore : score < bestScore)
            {
                bestScore = score;
                bestMove = (cell.Row, cell.Col);
            }
        }
        return (bestScore, bestMove);
    }

    private Mark Opponent() => aiMark == Mark.X ? Mark.O : Mark.X;
}

public class Player(string name, Mark mark, IPlayerStrategy strategy)
{
    public string Name => name;
    public Mark Mark => mark;
    public IPlayerStrategy Strategy => strategy;
}

// Human vs Easy AI
var playerX = new Player("Alice", Mark.X, new HumanStrategy());
var playerO = new Player("Bot", Mark.O, new RandomStrategy());

// Human vs Unbeatable AI
var playerO = new Player("Bot", Mark.O, new MinimaxStrategy(Mark.O));

// AI vs AI (for testing / simulation)
var playerX = new Player("Easy", Mark.X, new RandomStrategy());
var playerO = new Player("Hard", Mark.O, new MinimaxStrategy(Mark.O));

Diagrams

How Strategy Selection Works at Runtime

When it's a player's turn, the game asks the player for a move. The player delegates to its strategy. The strategy does the work and returns a position. The game never knows (or cares) what algorithm was used.

How Minimax Thinks — the Decision Tree

Minimax explores every possible future by building a tree. At each level, it alternates between maximizing (AI picks its best move) and minimizing (opponent picks their best response). Scores bubble up from the leaves — +10 for an AI win, -10 for a loss, 0 for a draw.

Strategy Pattern UML

The Player holds a reference to IPlayerStrategy. At game setup, you assign the right strategy — human, random, or minimax. The game loop never changes.

Growing Diagram — Level 4

Our design keeps expanding. The Player class is new — it holds a name, a mark, and a strategy. The game now manages two Player objects instead of raw marks.

Before / After Your Brain

Your inner voice:

"Every public method needs to handle bad input. But I don't want try-catch blocks in every method — that's noisy and exceptions are expensive for things we expect to happen (like typing a wrong number)."

"I could return error codes — like int where 0 = success, 1 = out of bounds, 2 = cell taken. But then the caller has to remember what each number means. And the actual result (like 'X wins') has to come through a separate channel. Ugly."

"What if the method returns a single object that says either 'here's your result' OR 'here's what went wrong'? Something like Result<T> — it holds a success value or an error message, never both. The caller checks IsSuccess and either uses the value or reads the error. No exceptions for expected failures. No magic numbers. No split channels."

What Would You Do?

Three ways to handle errors. One is heavy, one is cryptic, and one is just right.

public string PlaceMark(int row, int col)
{
    try
    {
        _board[row, col] = _currentMark;  // May throw IndexOutOfRange
        var result = CheckWinner();       // May throw anything
        ToggleTurn();
        return $"Placed at ({row},{col}). {result}";
    }
    catch (IndexOutOfRangeException)
    {
        return "Row and column must be 0-2.";
    }
    catch (InvalidOperationException ex)
    {
        return ex.Message;
    }
    catch (Exception ex)
    {
        return $"Something went wrong: {ex.Message}";
    }
}

public int PlaceMark(int row, int col, out GameResult result)
{
    result = default;

    if (row < 0 || row > 2 || col < 0 || col > 2)
        return 1;  // Out of bounds... but what's 1 again?

    if (_board[row, col] != Mark.None)
        return 2;  // Cell taken... or was that 3?

    _board[row, col] = _currentMark;
    result = CheckWinner();
    ToggleTurn();
    return 0;  // Success
}

// Caller has to remember the codes
var code = game.PlaceMark(r, c, out var result);
if (code == 1) Console.WriteLine("Out of bounds");
else if (code == 2) Console.WriteLine("Cell taken");
else Console.WriteLine(result);

public Result<GameResult> PlaceMark(int row, int col)
{
    if (row < 0 || row > 2 || col < 0 || col > 2)
        return Result<GameResult>.Fail("Position must be 0-2.");

    if (_board[row, col] != Mark.None)
        return Result<GameResult>.Fail("That cell is already taken.");

    _board[row, col] = _currentMark;
    ToggleTurn();
    return Result<GameResult>.Ok(CheckWinner());
}

// Caller: clean and obvious
var result = game.PlaceMark(r, c);
if (result.IsSuccess)
    Console.WriteLine(result.Value);
else
    Console.WriteLine($"Error: {result.Error}");

The Solution

The Result patternA pattern where methods return a Result object instead of throwing exceptions for expected failures. The Result holds either a success value or an error message. This forces the caller to handle both cases explicitly, making error handling visible and predictable. replaces "throw and pray someone catches it" with "return a clear answer that says yes or no." It's especially good for situations where failure is a normal part of the workflow — like user input validation.

public sealed record Result<T>
{
    public bool IsSuccess { get; }
    public T? Value { get; }
    public string? Error { get; }

    private Result(T value)
    {
        IsSuccess = true;
        Value = value;
        Error = null;
    }

    private Result(string error)
    {
        IsSuccess = false;
        Value = default;
        Error = error;
    }

    public static Result<T> Ok(T value) => new(value);
    public static Result<T> Fail(string error) => new(error);
}

public Result<GameResult> MakeMove(int row, int col)
{
    // 1. Is the game still going?
    if (!_currentState.CanPlaceMark)
        return Result<GameResult>.Fail(
            $"Can't play — {_currentState.Status}");

    // 2. Is the position on the board?
    if (row < 0 || row > 2 || col < 0 || col > 2)
        return Result<GameResult>.Fail(
            $"Position ({row},{col}) is out of bounds. Use 0-2.");

    // 3. Is the cell empty?
    if (_board[row, col] != Mark.None)
        return Result<GameResult>.Fail(
            $"Cell ({row},{col}) is already taken by {_board[row, col]}.");

    // All checks passed — execute the move
    var command = new MoveCommand(_currentMark, row, col);
    _history.Execute(command, _board);
    ToggleTurn();

    var result = CheckResult();
    if (result == GameResult.XWins || result == GameResult.OWins)
        TransitionTo(new WonState(result));
    else if (result == GameResult.Draw)
        TransitionTo(new DrawState());

    return Result<GameResult>.Ok(result);
}

while (game.IsInProgress)
{
    var (row, col) = currentPlayer.Strategy.GetMove(game.Board);
    var result = game.MakeMove(row, col);

    if (result.IsSuccess)
    {
        game.PrintBoard();
        Console.WriteLine($"Result: {result.Value}");
        game.SwitchPlayer();
    }
    else
    {
        // Error message is right there — no guessing
        Console.WriteLine(result.Error);
        // Don't switch player — let them try again
    }
}

Diagrams

Error Flow — Before vs. After Result<T>

On the left, errors happen unpredictably — exceptions fly, callers crash, users see stack traces. On the right, every error is anticipated and communicated cleanly through the return value.

Anatomy of Result<T>

A Result is like a sealed envelope. When you open it, you find either a present (the value) or a note explaining what went wrong (the error). It can never be both, and it can never be neither.

Growing Diagram — Level 5

One new piece joins the system: Result<T>. It sits at the boundary between the game and the outside world — every public method now returns a Result instead of a raw value. The internal classes stay the same.

Before / After Your Brain

Your inner voice:

Random.Shared is the root of the problem. It's a static global — I can't mock it, I can't control it, I can't predict it. I need to wrap it behind an interface. Something like IRandomProvider with a single method: Next(max). In production, I inject the real Random. In tests, I inject a FakeRandom that returns predetermined values.

Same story for time — luckily .NET 8 ships TimeProvider built in. I just use TimeProvider.System in production and a FakeTimeProvider in tests. For the board, I need a way to start from any mid-game position — either an IBoard interface or a constructor overload that accepts an initial board.

The pattern here is dead simple: if you can't control it from outside, you can't test it. Every "global" thing becomes an injected dependencyA dependency is any object your class needs to do its work. When the class creates dependencies internally (new Random()), they're hidden and uncontrollable. When they're passed in through the constructor, they're visible and swappable. That's the difference between untestable and testable..

What Would You Do?

Three developers, three approaches to making randomness testable. Read all three, then see which survives.

public sealed class RandomStrategy : IPlayerStrategy
{
    public Position ChooseMove(IBoard board)
    {
        var empty = board.GetEmptyCells();
        // 🚫 Random.Shared — can't control from outside
        return empty[Random.Shared.Next(empty.Count)];
    }
}

public static class RandomHelper
{
    // "Just set this in tests!" — famous last words
    public static Func<int, int> NextFunc = max => Random.Shared.Next(max);
}

public sealed class RandomStrategy : IPlayerStrategy
{
    public Position ChooseMove(IBoard board)
    {
        var empty = board.GetEmptyCells();
        return empty[RandomHelper.NextFunc(empty.Count)];
    }
}

public interface IRandomProvider
{
    int Next(int maxValue);
}

public sealed class RandomStrategy(IRandomProvider random) : IPlayerStrategy
{
    public Position ChooseMove(IBoard board)
    {
        var empty = board.GetEmptyCells();
        return empty[random.Next(empty.Count)]; // ✅ Injected — fully controllable
    }
}

The Solution — Injectable Everything

The core idea behind Dependency InjectionDependency Injection (DI) means giving an object the things it needs from the outside instead of letting it create them internally. Think of a restaurant: the chef doesn't grow the vegetables — they're delivered (injected). This makes the chef (your class) testable: swap in plastic vegetables (fakes) and verify the chef follows the recipe. is simple: every "global thing" your code touches — randomness, time, the board itself — becomes something you pass in through the constructor. In production you pass real implementations. In tests you pass fakes with predetermined behavior.

// The abstraction — one method, zero knowledge of implementation
public interface IRandomProvider
{
    int Next(int maxValue);
}

// Production implementation — delegates to the real Random
public sealed class SystemRandomProvider : IRandomProvider
{
    public int Next(int maxValue) => Random.Shared.Next(maxValue);
}

// Test implementation — returns predetermined values in order
public sealed class FakeRandomProvider(Queue<int> values) : IRandomProvider
{
    public int Next(int maxValue) => values.Dequeue();
}

// The game interface — controllers depend on this, not the concrete class
public interface ITicTacToeGame
{
    GameResult? Result { get; }
    IReadOnlyList<MoveCommand> History { get; }
    MoveResult MakeMove(int row, int col);
    void PlayToCompletion();
}

// Production wiring — real randomness, real time
builder.Services.AddSingleton<IRandomProvider, SystemRandomProvider>();
builder.Services.AddSingleton<TimeProvider>(TimeProvider.System);
builder.Services.AddTransient<ITicTacToeGame, TicTacToeGame>();

[Fact]
public void Minimax_Never_Loses_Against_Random()
{
    // Arrange — predetermined "random" moves
    var fakeRandom = new FakeRandomProvider(
        new Queue<int>([0, 1, 2, 0, 1]));

    var game = new TicTacToeGame(
        xStrategy: new MinimaxStrategy(),
        oStrategy: new RandomStrategy(fakeRandom));

    // Act
    game.PlayToCompletion();

    // Assert — Minimax (X) should never lose
    Assert.NotEqual(GameResult.OWins, game.Result);
}

[Fact]
public void Placing_On_Occupied_Cell_Returns_Error()
{
    // Arrange — set up a board with X already at (0,0)
    var board = new Board();
    board.Place(0, 0, Mark.X);
    var game = new TicTacToeGame(board, currentTurn: Mark.O);

    // Act
    var result = game.MakeMove(0, 0); // O tries the same cell

    // Assert
    Assert.False(result.Success);
    Assert.Equal("Cell is already occupied.", result.Error);
}

Before & After: Dependency Injection

On the left, randomness is baked into the class — sealed shut, untestable. On the right, randomness is passed in — the class is open to any implementation you choose.

How a Deterministic Test Works

The test creates fake versions of every dependency, wires them into the game, runs it, and checks the exact result. No surprises, no randomness, no flakiness — ever.

Growing Diagram — Level 6

Our system gains a testability layer. New abstractions (purple, dashed border) wrap every external dependency so tests can swap them out freely.

Your inner voice:

Multiple games at once... I need a GameManager that creates and tracks game instances by ID. Each game already has its own state and history from previous levels, so isolation is natural — no shared mutable state between games.

But notifications are the tricky part. When a move happens, the spectator UI needs to know. But the game engine shouldn't know about the UI — that would be tight couplingTight coupling means two components know too much about each other. If the game directly calls spectatorUI.Update(), then adding a leaderboard means editing the game class. Loose coupling means the game announces "something happened" and anyone who cares can listen — without the game knowing who they are.. I want the game to just say "hey, something happened" and let anyone who cares react. That's the Observer pattern — emit events, and any number of listeners can subscribe.

For tournaments, I need a bracket — basically a tree of matchups. Round 1 has 4 games. Winners advance to Round 2. Then a final. I'll model it as a list of rounds, each containing matchup records.

And replay? Wait... we already built that! The MoveCommand history from Level 3 is literally a replay log. Fresh board, apply each command in order. The Command pattern just paid for itself again.

What Would You Do?

The key design question: how do spectators learn about moves? Three approaches, only one scales.

public sealed class TicTacToeGame
{
    private readonly SpectatorDashboard _dashboard;
    private readonly Leaderboard _leaderboard;

    public void MakeMove(int row, int col)
    {
        // ... place mark ...
        _dashboard.Update(this);     // Game knows about UI
        _leaderboard.Refresh(this);  // Game knows about leaderboard
    }
}

// Spectator dashboard checks every 500ms
while (true)
{
    await Task.Delay(500);
    var state = game.GetCurrentState();
    if (state != lastKnownState)
    {
        Render(state);
        lastKnownState = state;
    }
}

public interface IGameEventListener
{
    void OnMoveMade(Guid gameId, MoveCommand move);
    void OnGameEnded(Guid gameId, GameResult result);
}

// Game doesn't know WHO listens — just announces events
public void Subscribe(IGameEventListener listener)
    => _listeners.Add(listener);

// Anyone can listen — zero coupling to the game
manager.Subscribe(new SpectatorDashboard());
manager.Subscribe(new ReplayRecorder());
manager.Subscribe(new LeaderboardService());

The Solution — GameManager + Tournament + Observer

We need three new pieces: a GameManager to track multiple simultaneous games, an Observer system so spectators get instant updates, and a Tournament class to manage brackets. Let's build them one at a time.

public sealed class GameManager
{
    private readonly ConcurrentDictionary<Guid, ITicTacToeGame> _games = new();
    private readonly List<IGameEventListener> _listeners = [];

    // Create a new game and get back its unique ID
    public Guid CreateGame(
        IPlayerStrategy? xStrategy = null,
        IPlayerStrategy? oStrategy = null)
    {
        var id = Guid.NewGuid();
        var game = new TicTacToeGame(xStrategy, oStrategy);
        _games[id] = game;
        return id;
    }

    // Anyone can subscribe to ALL game events
    public void Subscribe(IGameEventListener listener)
        => _listeners.Add(listener);

    // When a move happens, tell everyone who cares
    private void NotifyMoveMade(Guid gameId, MoveCommand move)
    {
        foreach (var listener in _listeners)
            listener.OnMoveMade(gameId, move);
    }

    private void NotifyGameEnded(Guid gameId, GameResult result)
    {
        foreach (var listener in _listeners)
            listener.OnGameEnded(gameId, result);
    }

    // Retrieve any game by ID (for spectator viewing)
    public ITicTacToeGame? GetGame(Guid id)
        => _games.GetValueOrDefault(id);
}

public sealed class Tournament
{
    // A single matchup: two players, optional game, optional winner
    public record Matchup(
        string PlayerA,
        string PlayerB,
        Guid? GameId = null,
        string? Winner = null);

    // Rounds[0] = first round, Rounds[^1] = final
    private readonly List<List<Matchup>> _rounds = [];

    // Pair players into a single-elimination bracket
    public void GenerateBracket(string[] players)
    {
        var shuffled = players.OrderBy(_ => Random.Shared.Next()).ToArray();
        var round = new List<Matchup>();

        for (int i = 0; i < shuffled.Length; i += 2)
            round.Add(new Matchup(shuffled[i], shuffled[i + 1]));

        _rounds.Add(round);
    }

    // Record a game result and advance the winner
    public void RecordResult(Guid gameId, string winner)
    {
        // Find the matchup, set the winner
        // Generate next round when all games in current round are done
    }

    public IReadOnlyList<IReadOnlyList<Matchup>> GetBracket()
        => _rounds;
}

// Replay is FREE — we already store MoveCommands from Level 3!
public static class GameReplayService
{
    public static void ReplayGame(IReadOnlyList<MoveCommand> history)
    {
        var board = new Board();

        foreach (var move in history)
        {
            board.Place(move.Row, move.Col, move.Mark);
            Console.WriteLine($"Turn {move.TurnNumber}: {move.Mark} → ({move.Row},{move.Col})");
            board.Print();
            Thread.Sleep(500); // Pause for dramatic effect
        }
    }
}

// Usage: replay any completed game
var game = manager.GetGame(gameId);
GameReplayService.ReplayGame(game!.History);

Tournament Bracket — 8-Player Single Elimination

Each round halves the remaining players. Four games in Round 1, two semi-finals, one grand final, one champion.

Observer Notification Flow

The game engine announces events. Any number of listeners react independently. The game has zero knowledge of who's listening or what they do with the information.

Growing Diagram — Level 7 (Complete Architecture)

This is the final picture. From a 20-line script in Level 0 to a full tournament system with observers, strategies, states, commands, and DI. Every single box was discovered by a constraint — not memorized from a textbook.

You've built this system piece by piece across seven levels. Now it's time to see the whole thing in one place. Every file below is the final, production-ready version — incorporating every pattern and refinement we discovered along the way.

Before we dive into the code, here's a bird's-eye view of every type in the system, color-coded by the level that introduced it. Green types appeared early (Levels 0–1), yellow ones came in the middle (Levels 2–4), and red ones were added in the advanced levels (5–7). Notice how the system grew organically — each type was forced into existence by a real constraint, not by upfront planning.

Now let's see the actual code. Each file is organized by responsibility — models in one place, states in another, strategies in a third. Click through the tabs to read each file.

namespace TicTacToe.Models;

// ─── Mark ───────────────────────────────────────────
// The two symbols that can occupy a cell.
// "None" means the cell is empty.
public enum Mark { None, X, O }

// ─── Position ───────────────────────────────────────
// A (row, col) coordinate on the board. Records give us
// value equality for free: two Positions with the same
// row and col are considered equal without writing Equals().
public readonly record struct Position(int Row, int Col);

// ─── Cell ───────────────────────────────────────────
// A single square on the board: its coordinate + what's in it.
public readonly record struct Cell(Position Pos, Mark Mark);

// ─── WinLine ────────────────────────────────────────
// When someone wins, this captures WHO won and WHICH three
// cells formed the winning line (useful for highlighting).
public record WinLine(Mark Winner, IReadOnlyList<Position> Cells);

// ─── MoveCommand ────────────────────────────────────
// Every move is stored as an immutable record — this is
// the Command pattern in action. We can replay, undo, or
// transmit these over the network because they're just data.
public record MoveCommand(
    int TurnNumber,  // Which turn this was (1, 2, 3...)
    Mark Mark,       // Who placed this mark (X or O)
    int Row,         // Board row (0-2)
    int Col          // Board column (0-2)
);

// ─── MoveResult ─────────────────────────────────────
// The outcome of attempting a move. Either it succeeded
// (and possibly ended the game), or it failed with a reason.
public record MoveResult(
    bool Success,
    string? Error = null,
    WinLine? WinLine = null,
    bool IsDraw = false
);

// ─── GameResult<T> ──────────────────────────────────
// A generic result wrapper — either a value or an error.
// Used for operations that might fail (like starting a
// game that's already started).
public record GameResult<T>(T? Value, string? Error = null)
{
    public bool IsSuccess => Error is null;
    public static GameResult<T> Ok(T value) => new(value);
    public static GameResult<T> Fail(string error) => new(default, error);
}

// ─── Player ─────────────────────────────────────────
// Pairs a mark (X or O) with a strategy for choosing moves.
// This lets us mix human and AI players freely.
public record Player(Mark Mark, IPlayerStrategy Strategy);

// ─── Board ──────────────────────────────────────────
// The 3x3 grid. Encapsulates all board logic: placing marks,
// checking for wins, listing empty cells.
public sealed class Board
{
    private readonly Mark[,] _grid = new Mark[3, 3];

    // Place a mark at the given position
    public bool Place(int row, int col, Mark mark)
    {
        if (row < 0 || row > 2 || col < 0 || col > 2)
            return false; // Out of bounds
        if (_grid[row, col] != Mark.None)
            return false; // Already occupied

        _grid[row, col] = mark;
        return true;
    }

    // Remove a mark (used by Undo)
    public void Clear(int row, int col) => _grid[row, col] = Mark.None;

    // Read a cell's value
    public Mark this[int row, int col] => _grid[row, col];

    // All empty cells — used by AI strategies to find valid moves
    public List<Position> GetEmptyCells()
    {
        var cells = new List<Position>();
        for (int r = 0; r < 3; r++)
            for (int c = 0; c < 3; c++)
                if (_grid[r, c] == Mark.None)
                    cells.Add(new Position(r, c));
        return cells;
    }

    // Check all 8 possible winning lines (3 rows, 3 cols, 2 diagonals)
    public WinLine? CheckWinner()
    {
        // All 8 lines that can form a win
        Position[][] lines =
        [
            [new(0,0), new(0,1), new(0,2)], // Row 0
            [new(1,0), new(1,1), new(1,2)], // Row 1
            [new(2,0), new(2,1), new(2,2)], // Row 2
            [new(0,0), new(1,0), new(2,0)], // Col 0
            [new(0,1), new(1,1), new(2,1)], // Col 1
            [new(0,2), new(1,2), new(2,2)], // Col 2
            [new(0,0), new(1,1), new(2,2)], // Main diagonal
            [new(0,2), new(1,1), new(2,0)], // Anti-diagonal
        ];

        foreach (var line in lines)
        {
            var mark = _grid[line[0].Row, line[0].Col];
            if (mark != Mark.None
                && mark == _grid[line[1].Row, line[1].Col]
                && mark == _grid[line[2].Row, line[2].Col])
            {
                return new WinLine(mark, line);
            }
        }
        return null; // No winner yet
    }

    // Is the board completely full? (Draw check)
    public bool IsFull => GetEmptyCells().Count == 0;

    // Pretty-print for console output
    public void Print()
    {
        for (int r = 0; r < 3; r++)
        {
            for (int c = 0; c < 3; c++)
            {
                var symbol = _grid[r, c] switch
                {
                    Mark.X => "X",
                    Mark.O => "O",
                    _ => "."
                };
                Console.Write($" {symbol} ");
                if (c < 2) Console.Write("|");
            }
            Console.WriteLine();
            if (r < 2) Console.WriteLine("---+---+---");
        }
    }
}

namespace TicTacToe.States;

// ─── The contract every game state must follow ──────
// Each state answers: "What happens when the player
// tries to place a mark right now?"
public interface IGameState
{
    MoveResult PlaceMark(TicTacToeGame game, int row, int col);
    bool CanPlaceMark { get; }
    string StatusMessage { get; }
}

// ─── NotStartedState ────────────────────────────────
// The game exists but nobody has called Start() yet.
// Every action is rejected with a helpful message.
public sealed class NotStartedState : IGameState
{
    public bool CanPlaceMark => false;
    public string StatusMessage => "Waiting to start. Call Start() first.";

    public MoveResult PlaceMark(TicTacToeGame game, int row, int col)
        => new(Success: false, Error: "Game hasn't started yet.");
}

// ─── InProgressState ────────────────────────────────
// The ONLY state where real gameplay happens. Validates
// the move, places the mark, checks for a winner or
// draw, and transitions to the appropriate next state.
public sealed class InProgressState : IGameState
{
    public bool CanPlaceMark => true;
    public string StatusMessage => "Game in progress";

    public MoveResult PlaceMark(TicTacToeGame game, int row, int col)
    {
        // 1. Validate the move
        if (!game.Board.Place(row, col, game.CurrentMark))
            return new MoveResult(false, Error: "Invalid move: cell occupied or out of bounds.");

        // 2. Record it as a command (for undo/replay)
        game.RecordMove(new MoveCommand(
            TurnNumber: game.MoveHistory.Count + 1,
            Mark: game.CurrentMark,
            Row: row, Col: col));

        // 3. Check if this move wins the game
        var winLine = game.Board.CheckWinner();
        if (winLine is not null)
        {
            game.TransitionTo(new WonState(winLine));
            return new MoveResult(true, WinLine: winLine);
        }

        // 4. Check if the board is full (draw)
        if (game.Board.IsFull)
        {
            game.TransitionTo(new DrawState());
            return new MoveResult(true, IsDraw: true);
        }

        // 5. No winner, no draw — toggle turn and continue
        game.ToggleTurn();
        return new MoveResult(true);
    }
}

// ─── WonState ───────────────────────────────────────
// Someone won. The game is frozen — no more moves allowed.
// Stores the winning line so UI can highlight it.
public sealed class WonState(WinLine winLine) : IGameState
{
    public bool CanPlaceMark => false;
    public string StatusMessage => $"{winLine.Winner} wins!";
    public WinLine WinLine { get; } = winLine;

    public MoveResult PlaceMark(TicTacToeGame game, int row, int col)
        => new(false, Error: $"Game is over. {winLine.Winner} already won.");
}

// ─── DrawState ──────────────────────────────────────
// Board is full with no winner. Game over, but nobody lost.
public sealed class DrawState : IGameState
{
    public bool CanPlaceMark => false;
    public string StatusMessage => "It's a draw!";

    public MoveResult PlaceMark(TicTacToeGame game, int row, int col)
        => new(false, Error: "Game is over. It's a draw.");
}

namespace TicTacToe.Strategies;

// ─── The contract for choosing a move ───────────────
// Any strategy — human, random, genius AI — implements
// this one method. The game engine doesn't care HOW
// the move is chosen, only that it gets a Position back.
public interface IPlayerStrategy
{
    Position ChooseMove(Board board, Mark currentMark);
}

// ─── RandomStrategy ─────────────────────────────────
// Picks a random empty cell. Used for "Easy" AI.
// Note: randomness is INJECTED, not hardcoded — this
// makes the strategy fully testable.
public sealed class RandomStrategy(IRandomProvider random) : IPlayerStrategy
{
    public Position ChooseMove(Board board, Mark currentMark)
    {
        var emptyCells = board.GetEmptyCells();
        return emptyCells[random.Next(emptyCells.Count)];
    }
}

// ─── SmartStrategy ──────────────────────────────────
// A middle-ground AI: wins if it can, blocks if it must,
// otherwise picks a random cell. "Medium" difficulty.
public sealed class SmartStrategy(IRandomProvider random) : IPlayerStrategy
{
    public Position ChooseMove(Board board, Mark currentMark)
    {
        var opponent = currentMark == Mark.X ? Mark.O : Mark.X;

        // 1. Can I win right now? Take it!
        var winMove = FindWinningMove(board, currentMark);
        if (winMove.HasValue) return winMove.Value;

        // 2. Can opponent win next turn? Block it!
        var blockMove = FindWinningMove(board, opponent);
        if (blockMove.HasValue) return blockMove.Value;

        // 3. Take center if available (strongest position)
        if (board[1, 1] == Mark.None) return new Position(1, 1);

        // 4. Otherwise pick randomly
        var emptyCells = board.GetEmptyCells();
        return emptyCells[random.Next(emptyCells.Count)];
    }

    // Try every empty cell — if placing the mark there wins, return it
    private static Position? FindWinningMove(Board board, Mark mark)
    {
        foreach (var cell in board.GetEmptyCells())
        {
            board.Place(cell.Row, cell.Col, mark);
            var win = board.CheckWinner();
            board.Clear(cell.Row, cell.Col); // undo the probe
            if (win is not null) return cell;
        }
        return null;
    }
}

// ─── MinimaxStrategy ────────────────────────────────
// The unbeatable AI. Explores EVERY possible future game
// state and picks the move that guarantees the best outcome.
// Against perfect play, the result is always a draw.
public sealed class MinimaxStrategy : IPlayerStrategy
{
    public Position ChooseMove(Board board, Mark currentMark)
    {
        var bestScore = int.MinValue;
        Position bestMove = default;

        foreach (var cell in board.GetEmptyCells())
        {
            board.Place(cell.Row, cell.Col, currentMark);
            int score = Minimax(board, depth: 0,
                isMaximizing: false, aiMark: currentMark);
            board.Clear(cell.Row, cell.Col);

            if (score > bestScore)
            {
                bestScore = score;
                bestMove = cell;
            }
        }
        return bestMove;
    }

    // Recursively evaluate all possible game continuations
    private static int Minimax(Board board, int depth,
        bool isMaximizing, Mark aiMark)
    {
        var opponent = aiMark == Mark.X ? Mark.O : Mark.X;
        var winner = board.CheckWinner();

        // Base cases: someone won, or board is full
        if (winner?.Winner == aiMark) return 10 - depth;   // AI wins (prefer faster wins)
        if (winner?.Winner == opponent) return depth - 10;  // Opponent wins (prefer slower losses)
        if (board.IsFull) return 0;                         // Draw

        var currentMark = isMaximizing ? aiMark : opponent;
        var bestScore = isMaximizing ? int.MinValue : int.MaxValue;

        foreach (var cell in board.GetEmptyCells())
        {
            board.Place(cell.Row, cell.Col, currentMark);
            int score = Minimax(board, depth + 1, !isMaximizing, aiMark);
            board.Clear(cell.Row, cell.Col);

            bestScore = isMaximizing
                ? Math.Max(bestScore, score)
                : Math.Min(bestScore, score);
        }
        return bestScore;
    }
}

namespace TicTacToe;

// ─── ITicTacToeGame ─────────────────────────────────
// The public contract for the game engine. Controllers,
// UIs, and tests depend on THIS, not the concrete class.
public interface ITicTacToeGame
{
    Board Board { get; }
    Mark CurrentMark { get; }
    IReadOnlyList<MoveCommand> MoveHistory { get; }
    string Status { get; }
    bool IsGameOver { get; }

    MoveResult MakeMove(int row, int col);
    MoveResult Undo();
    void Start();
    void PlayToCompletion();
}

// ─── TicTacToeGame ──────────────────────────────────
// The orchestrator. Doesn't contain game logic itself —
// delegates to the current STATE for move handling, and
// to STRATEGIES for AI move selection.
public sealed class TicTacToeGame : ITicTacToeGame
{
    private IGameState _currentState = new NotStartedState();
    private readonly List<MoveCommand> _history = [];
    private readonly Stack<MoveCommand> _redoStack = new();

    // ─ Dependencies (all injected) ─
    private readonly Player _playerX;
    private readonly Player _playerO;

    // ─ Constructors ─
    public TicTacToeGame(
        IPlayerStrategy? xStrategy = null,
        IPlayerStrategy? oStrategy = null)
    {
        _playerX = new Player(Mark.X, xStrategy!);
        _playerO = new Player(Mark.O, oStrategy!);
        Board = new Board();
    }

    // Test constructor: start from a specific board state
    public TicTacToeGame(Board board, Mark currentTurn = Mark.X)
    {
        Board = board;
        CurrentMark = currentTurn;
        _playerX = new Player(Mark.X, null!);
        _playerO = new Player(Mark.O, null!);
        _currentState = new InProgressState();
    }

    // ─ Properties ─
    public Board Board { get; }
    public Mark CurrentMark { get; private set; } = Mark.X;
    public IReadOnlyList<MoveCommand> MoveHistory => _history;
    public string Status => _currentState.StatusMessage;
    public bool IsGameOver => !_currentState.CanPlaceMark
        && _currentState is not NotStartedState;

    // ─ State management ─
    public void TransitionTo(IGameState newState)
        => _currentState = newState;

    public void ToggleTurn()
        => CurrentMark = CurrentMark == Mark.X ? Mark.O : Mark.X;

    public void RecordMove(MoveCommand cmd)
    {
        _history.Add(cmd);
        _redoStack.Clear(); // New move invalidates redo stack
    }

    // ─ Core operations ─
    public void Start() => _currentState = new InProgressState();

    public MoveResult MakeMove(int row, int col)
        => _currentState.PlaceMark(this, row, col);

    // ─ Undo: pop the last move and rewind ─
    public MoveResult Undo()
    {
        if (_history.Count == 0)
            return new MoveResult(false, Error: "Nothing to undo.");

        // If game is over, revert to InProgress first
        if (IsGameOver)
            _currentState = new InProgressState();

        var lastMove = _history[^1];
        _history.RemoveAt(_history.Count - 1);
        _redoStack.Push(lastMove);

        Board.Clear(lastMove.Row, lastMove.Col);
        ToggleTurn();

        return new MoveResult(true);
    }

    // ─ Auto-play: let strategies play until game ends ─
    public void PlayToCompletion()
    {
        if (_currentState is NotStartedState) Start();

        while (_currentState.CanPlaceMark)
        {
            var player = CurrentMark == Mark.X ? _playerX : _playerO;
            var pos = player.Strategy.ChooseMove(Board, CurrentMark);
            MakeMove(pos.Row, pos.Col);
        }
    }
}

using Microsoft.Extensions.DependencyInjection;
using TicTacToe;
using TicTacToe.Models;
using TicTacToe.Strategies;

// ─── Wire up the dependency injection container ─────
var services = new ServiceCollection();

// Randomness: inject the real provider for production
services.AddSingleton<IRandomProvider, SystemRandomProvider>();

// Strategies: registered by name for easy swapping
services.AddTransient<RandomStrategy>();
services.AddTransient<SmartStrategy>();
services.AddTransient<MinimaxStrategy>();

var provider = services.BuildServiceProvider();

// ─── Game setup ─────────────────────────────────────
Console.WriteLine("=== Tic-Tac-Toe ===");
Console.WriteLine("Choose difficulty: (1) Easy  (2) Medium  (3) Impossible");
var choice = Console.ReadLine();

// Pick the AI strategy based on user choice
IPlayerStrategy aiStrategy = choice switch
{
    "1" => provider.GetRequiredService<RandomStrategy>(),
    "2" => provider.GetRequiredService<SmartStrategy>(),
    "3" => provider.GetRequiredService<MinimaxStrategy>(),
    _ => provider.GetRequiredService<SmartStrategy>()
};

// Human player is X, AI is O
var game = new TicTacToeGame(
    xStrategy: null!, // Human — moves come from console input
    oStrategy: aiStrategy);

game.Start();

// ─── The game loop ──────────────────────────────────
while (!game.IsGameOver)
{
    Console.WriteLine();
    game.Board.Print();
    Console.WriteLine($"\n{game.CurrentMark}'s turn.");

    if (game.CurrentMark == Mark.X) // Human's turn
    {
        Console.Write("Enter row,col (e.g. 1,2) or 'u' to undo: ");
        var input = Console.ReadLine()?.Trim();

        if (input == "u")
        {
            // Undo twice: the AI's last move + the human's last move
            game.Undo();
            game.Undo();
            continue;
        }

        var parts = input?.Split(',');
        if (parts?.Length == 2
            && int.TryParse(parts[0], out var row)
            && int.TryParse(parts[1], out var col))
        {
            var result = game.MakeMove(row, col);
            if (!result.Success)
            {
                Console.WriteLine($"Invalid move: {result.Error}");
                continue;
            }
        }
    }
    else // AI's turn
    {
        var pos = aiStrategy.ChooseMove(game.Board, Mark.O);
        var result = game.MakeMove(pos.Row, pos.Col);
        Console.WriteLine($"AI plays ({pos.Row},{pos.Col})");
    }
}

// ─── Game over ──────────────────────────────────────
Console.WriteLine();
game.Board.Print();
Console.WriteLine($"\n{game.Status}");
Console.WriteLine("\nMove history:");
foreach (var move in game.MoveHistory)
    Console.WriteLine($"  Turn {move.TurnNumber}: {move.Mark} → ({move.Row},{move.Col})");

You've been using design patterns for the last seven levels. But here's the interesting part: you might not have noticed all of them. Some patterns are obvious — we named them as we built them. Others are hiding in the code, doing their job quietly without anyone putting a label on them.

This section is about developing pattern recognitionThe ability to look at code and see the underlying design patterns at work. Senior engineers do this unconsciously — they glance at code and immediately see "that's a Strategy" or "that's a Command." This skill comes from practice: once you've built patterns yourself, you spot them everywhere. — the skill of looking at code and seeing the structural bones underneath. Let's start with a challenge.

The Three Explicit Patterns

These are the patterns we named during the build. For each one, we'll look at where it lives in the code, what it enables, and what would happen without it.

Pattern X-Ray — See Through the Code

Here's the class diagram again, but this time with colored overlays showing which pattern each type belongs to. Blue is State, cyan is Command, and orange is Strategy. Some types serve multiple patterns — that's normal and healthy.

How the Patterns Interact

Patterns don't live in isolation. Here's how they collaborateIn well-designed systems, patterns work together like gears in a machine. State delegates to Strategy (the InProgressState asks the player's strategy for a move). Strategy produces a move that becomes a Command. The Command gets stored and can be replayed. Each pattern handles one concern and passes the result to the next. in a single move cycle: the State pattern decides IF a move is allowed, the Strategy pattern decides WHERE to move, and the Command pattern records WHAT happened.

You've just spent seven levels building a Tic-Tac-Toe game. At Level 0 it was a single class with a 2D array. By Level 7, it's a clean architecture with interfaces, records, strategies, and events. But it didn't happen all at once — it grew one constraint at a time. Let's zoom out and watch the whole journey unfold.

Each level below shows what was added at that stage. Glowing boxes are new arrivals; dimmed boxes are types that already existed from earlier levels. Pay attention to the growth curveThe growth curve shows how many types (classes, interfaces, records, enums) exist at each level. A healthy design grows gradually — 1 or 2 new types per level. An unhealthy design dumps 15 types in one go because someone tried to "design everything up front." — it stays gentle because we never added more than one concept at a time.

Here's the complete picture — every entity, its type, and the level that introduced it.

Final Architecture — All Patterns Working Together

Here's the complete class diagram after Level 7. Each color represents the pattern that introduced that type. Notice how the patterns compose cleanlyGood patterns don't fight each other. State decides IF a move is allowed. Strategy decides WHERE to move. Command records WHAT happened. Observer notifies WHO cares. Each handles one concern and passes the baton to the next. This composability is what makes the design feel natural rather than forced. — State delegates to Strategy, Strategy produces moves that become Commands, and Commands fire Events through the Observer.

You've seen the good solution — built incrementally over 7 levels. Now let's study five bad approaches that people commonly reach for. Each one is tempting for a different reason, and each one breaks in a different way. We'll walk through the exact code, show you an SVG of the problem, and demonstrate the fix.

public class TicTacToeGame
{
    private char[,] board = new char[3, 3];
    private bool isStarted, isOver, isWon;
    private char currentPlayer = 'X';
    private List<(int r, int c, char mark)> history = new();

    public void MakeMove(int row, int col)
    {
        if (!isStarted) { Console.WriteLine("Game not started!"); return; }
        if (isOver) { Console.WriteLine("Game already over!"); return; }
        if (board[row, col] != '\0') { Console.WriteLine("Spot taken!"); return; }

        board[row, col] = currentPlayer;
        history.Add((row, col, currentPlayer));
        Console.WriteLine($"{currentPlayer} placed at ({row},{col})");

        // Win check — inline, 20+ lines of nested loops
        for (int i = 0; i < 3; i++)
        {
            if (board[i,0] == currentPlayer && board[i,1] == currentPlayer
                && board[i,2] == currentPlayer)
            { isWon = true; isOver = true; }
        }
        // ... 40 more lines of win/draw checking ...

        if (isWon) Console.WriteLine($"{currentPlayer} wins!");
        currentPlayer = currentPlayer == 'X' ? 'O' : 'X';

        // AI move — also inline
        if (!isOver && currentPlayer == 'O')
        {
            var rng = new Random();
            // ... 30 lines of AI logic mixed into the game class ...
        }
    }
    // ... 200 more lines: undo, display, reset, scoring ...
}

// Board: ONLY grid management and win detection
public sealed class Board
{
    public bool TryPlace(int row, int col, CellMark mark) { ... }
    public WinLine? CheckWinner() { ... }
}

// State: ONLY "is this move allowed right now?"
public interface IGameState
{
    MoveResult HandleMove(Game game, int row, int col);
}

// Command: ONLY recording and reversing moves
public record MoveCommand(int Row, int Col, CellMark Mark);

// Strategy: ONLY choosing WHERE to move
public interface IPlayerStrategy
{
    (int Row, int Col) PickMove(Board board);
}

// Observer: ONLY notifying external systems
public interface IGameObserver
{
    void OnMoveMade(MoveMadeEvent e);
    void OnGameOver(GameOverEvent e);
}

public class TicTacToeGame
{
    private bool isStarted = false;
    private bool isOver = false;
    private bool isWon = false;
    private bool isDraw = false;   // can isWon AND isDraw both be true?

    public void MakeMove(int row, int col)
    {
        if (!isStarted) throw new InvalidOperationException("Not started");
        if (isOver) throw new InvalidOperationException("Game over");
        if (isWon) throw new InvalidOperationException("Already won");  // redundant?
        if (isDraw) throw new InvalidOperationException("Already drawn"); // also redundant?

        // Place the mark...
        board[row, col] = currentPlayer;

        if (CheckWin())
        {
            isWon = true;
            isOver = true;
            // Bug: forgot to set isDraw = false explicitly
            // What if someone set isDraw = true earlier by accident?
        }
        else if (IsBoardFull())
        {
            isDraw = true;
            isOver = true;
        }
    }

    public void Reset()
    {
        isStarted = true;
        isOver = false;
        isWon = false;
        // Bug: forgot to reset isDraw!
        // Now isDraw = true from the previous game
    }
}

// The game is ALWAYS in exactly ONE state
public interface IGameState
{
    MoveResult HandleMove(Game game, int row, int col);
}

public sealed class InProgressState : IGameState
{
    public MoveResult HandleMove(Game game, int row, int col)
    {
        // This is the ONLY state where moves are allowed
        // No boolean checks needed — the type system enforces it
        game.Board.TryPlace(row, col, game.CurrentMark);
        var winner = game.Board.CheckWinner();
        if (winner is not null)
            game.TransitionTo(new WonState(winner));
        else if (game.Board.IsFull)
            game.TransitionTo(new DrawState());
        return MoveResult.Success;
    }
}

// Can't be Won AND Draw — there's only ONE state object at a time
// Can't forget to reset — new game = new NotStartedState()

public class TicTacToeGame
{
    private char[,] board = new char[3, 3];
    private Stack<char[,]> snapshots = new();  // entire board copies!

    public void MakeMove(int row, int col)
    {
        // Save a FULL COPY of the board before every move
        snapshots.Push((char[,])board.Clone());  // O(n) per move
        board[row, col] = currentPlayer;
    }

    public void Undo()
    {
        if (snapshots.Count == 0) return;
        board = snapshots.Pop();  // restore the entire board
        // Bug: what about currentPlayer? State? Turn count?
        // None of those were saved in the snapshot!
    }
}

// Each command records WHAT happened — not the entire board
public record MoveCommand(int Row, int Col, CellMark Mark);

public sealed class Game
{
    private readonly Stack<MoveCommand> _history = new();
    private readonly Stack<MoveCommand> _redoStack = new();

    public MoveResult MakeMove(int row, int col)
    {
        var command = new MoveCommand(row, col, CurrentMark);
        _board.TryPlace(row, col, CurrentMark);
        _history.Push(command);
        _redoStack.Clear();
        return MoveResult.Success;
    }

    public void Undo()
    {
        if (_history.Count == 0) return;
        var cmd = _history.Pop();
        _board.Clear(cmd.Row, cmd.Col);  // reverse just ONE cell
        _redoStack.Push(cmd);
        // State, turn, everything stays consistent
    }
}

public class Board
{
    private char[,] grid = new char[3, 3];  // magic 3

    public bool CheckWin(char player)
    {
        // Rows
        for (int r = 0; r < 3; r++)           // magic 3
            if (grid[r,0] == player && grid[r,1] == player
                && grid[r,2] == player)       // magic 3
                return true;

        // Columns
        for (int c = 0; c < 3; c++)           // magic 3
            if (grid[0,c] == player && grid[1,c] == player
                && grid[2,c] == player)       // magic 3
                return true;

        // Diagonals — hardcoded indices
        if (grid[0,0] == player && grid[1,1] == player
            && grid[2,2] == player)           // magic 3
            return true;

        return false;
    }

    public bool IsFull()
    {
        int count = 0;
        for (int r = 0; r < 3; r++)           // magic 3
            for (int c = 0; c < 3; c++)       // magic 3
                if (grid[r, c] != '\0') count++;
        return count == 9;                     // magic 9 = 3 * 3
    }
}

public sealed class Board
{
    private readonly CellMark[,] _grid;
    public int Size { get; }
    public int WinLength { get; }

    public Board(int size = 3, int winLength = 3)
    {
        Size = size;
        WinLength = winLength;
        _grid = new CellMark[size, size];
    }

    public WinLine? CheckWinner()
    {
        // Uses Size and WinLength — works for any board
        for (int r = 0; r < Size; r++)
            for (int c = 0; c < Size; c++)
                foreach (var dir in Directions)
                    if (CheckLine(r, c, dir, WinLength) is WinLine w)
                        return w;
        return null;
    }

    public bool IsFull => _moveCount == Size * Size;  // derived!
}

// 3x3 classic:   new Board(3, 3)
// 5x5 gomoku:    new Board(5, 4)
// 15x15 gomoku:  new Board(15, 5)

public class Board
{
    public void Place(int row, int col, char mark)
    {
        grid[row, col] = mark;
        Console.WriteLine($"{mark} placed at ({row},{col})");  // UI in Board!
        PrintBoard();  // Board knows how to render itself to console
    }

    private void PrintBoard()
    {
        for (int r = 0; r < 3; r++)
        {
            Console.WriteLine($" {grid[r,0]} | {grid[r,1]} | {grid[r,2]} ");
            if (r < 2) Console.WriteLine("---+---+---");
        }
    }
}

public class Game
{
    public void Start()
    {
        Console.Clear();             // assumes a console exists
        Console.ForegroundColor = ConsoleColor.Cyan;  // crashes in web
        Console.WriteLine("=== TIC-TAC-TOE ===");
    }
}

// Game engine has ZERO Console references
public sealed class Game
{
    private readonly List<IGameObserver> _observers = new();

    public void MakeMove(int row, int col)
    {
        // ... game logic ...
        foreach (var obs in _observers)
            obs.OnMoveMade(new MoveMadeEvent(row, col, CurrentMark));
    }
}

// Console UI — one possible observer
public sealed class ConsoleRenderer : IGameObserver
{
    public void OnMoveMade(MoveMadeEvent e)
        => Console.WriteLine($"{e.Mark} placed at ({e.Row},{e.Col})");
}

// Web API — another observer, zero engine changes
public sealed class WebSocketNotifier : IGameObserver
{
    public void OnMoveMade(MoveMadeEvent e)
        => _hub.Clients.All.SendAsync("moveMade", e);
}

// Unit test — silent observer
public sealed class TestObserver : IGameObserver { /* collect events */ }

Coupling Comparison — Bad vs Good

A candidate submitted this Tic-Tac-Toe implementation as a pull request. It compiles. It runs. It handles a basic game from start to finish. But there are exactly 5 bugs hiding in it — issues that would cause real problems in production. Can you find them all before scrolling down?

Read the code below carefully. Try to find all 5 issues before revealing the answers.

public class TicTacToeGame                                      // Line 1
{
    private char[,] board = new char[3, 3];                     // Line 3
    private bool isStarted, isOver;
    private char currentPlayer = 'X';
    private List<(int r, int c, char mark)> history = new();

    public string MakeMove(int row, int col)                    // Line 8
    {
        if (!isStarted) return "Game not started";
        if (isOver) return "Game is over";
        if (board[row, col] != '\0') return "Spot taken";       // Line 12

        board[row, col] = currentPlayer;
        history.Add((row, col, currentPlayer));
        Console.WriteLine($"Board updated: {currentPlayer} at ({row},{col})");

        if (CheckWin(currentPlayer))                            // Line 17
        {
            isOver = true;
            return $"{currentPlayer} wins!";
            // Note: currentPlayer never switches after this
        }

        if (history.Count == 9)                                 // Line 23
        {
            isOver = true;
            return "Draw!";
        }

        currentPlayer = currentPlayer == 'X' ? 'O' : 'X';
        return "OK";
    }

    public void Undo()                                          // Line 31
    {
        if (history.Count == 0) return;
        var last = history[^1];
        history.RemoveAt(history.Count - 1);
        board[last.r, last.c] = '\0';
        // That's it — no state restoration
    }

    private bool CheckWin(char p)                               // Line 40
    {
        for (int i = 0; i < 3; i++)
        {
            if (board[i,0]==p && board[i,1]==p && board[i,2]==p) return true;
            if (board[0,i]==p && board[1,i]==p && board[2,i]==p) return true;
        }
        if (board[0,0]==p && board[1,1]==p && board[2,2]==p) return true;
        // Missing: anti-diagonal check!                        // Line 47
        return false;
    }
}

Found them? Reveal one at a time:

Tic-Tac-Toe looks like a toy problem. That's exactly why interviewers love it — most candidates underestimate it, rush to code, and miss the design decisions hiding inside a "simple" game. Below you'll see two interview runs: the polished one and the realistic one (with stumbles). Both get hired. The difference is how they recover.

Here’s something most candidates get wrong: they treat articulation as a side-effect of knowing the design. It isn’t. Design skill and communication skill are separate muscles — you can have a brilliant Tic-Tac-Toe design locked in your head and still tank the interview because you can’t narrate it under pressure. The 8 cards below cover the exact situations where phrasing matters most.

10 questions ranked by difficulty. Each has a "Think" prompt, a solid answer, and the great answer that gets "Strong Hire." These aren't hypothetical — they're the exact questions interviewers ask when they see a Tic-Tac-Toe design.

private readonly Stack<IMoveCommand> _history = new();
private readonly Stack<IMoveCommand> _redoStack = new();

public Result<GameResult> PlaceMark(int row, int col)
{
    var cmd = new PlaceMarkCommand(_board, row, col, CurrentPlayer);
    var result = cmd.Execute();       // place the mark
    if (result.IsSuccess)
    {
        _history.Push(cmd);           // remember it
        _redoStack.Clear();           // new move = new timeline
    }
    return result;
}

public bool Undo()
{
    if (_history.Count == 0) return false;
    var cmd = _history.Pop();
    cmd.Undo();                       // reverse the mark
    _redoStack.Push(cmd);             // save for redo
    return true;
}

// Existing strategies -- untouched
public sealed class RandomStrategy : IPlayerStrategy { ... }
public sealed class MinimaxStrategy : IPlayerStrategy { ... }

// NEW: depth-limited minimax -- just add this file
public sealed class DepthLimitedStrategy(int maxDepth = 3) : IPlayerStrategy
{
    public (int Row, int Col) ChooseMove(Board board, Mark mark)
    {
        // Minimax but stops at maxDepth instead of exploring everything
        return Minimax(board, mark, depth: 0, maxDepth);
    }
}

// Game class: zero changes. Just inject the new strategy.
var game = new Game(new HumanPlayer(), new AiPlayer(new DepthLimitedStrategy(3)));

// Fake player that returns scripted moves -- no console input needed
public sealed class ScriptedPlayer(Queue<(int, int)> moves) : IPlayer
{
    public Mark Mark { get; init; }
    public (int Row, int Col) GetMove(Board board) => moves.Dequeue();
}

[Fact]
public void X_wins_with_top_row()
{
    var x = new ScriptedPlayer(new([(0,0), (0,1), (0,2)])) { Mark = Mark.X };
    var o = new ScriptedPlayer(new([(1,0), (1,1)]))         { Mark = Mark.O };
    var game = new Game(x, o);

    game.PlayToEnd();

    Assert.Equal(GameStatus.Won, game.Status);
    Assert.Equal(Mark.X, game.Winner);
}

// Game publishes events -- doesn't know who listens
public sealed class Game
{
    public event Action<Mark, int, int>? OnMovePlaced;
    public event Action<GameResult>? OnGameOver;

    public Result<GameResult> PlaceMark(int row, int col)
    {
        // ... place mark, check winner ...
        OnMovePlaced?.Invoke(CurrentPlayer, row, col);
        if (gameResult is not null)
            OnGameOver?.Invoke(gameResult);
    }
}

// Console subscribes -- Game doesn't know this class exists
game.OnMovePlaced += (mark, r, c) => Console.WriteLine($"{mark} at ({r},{c})");
game.OnGameOver += result => Console.WriteLine($"Game over: {result}");

Every one of these has ended real interviews. They're especially dangerous on a "simple" problem like Tic-Tac-Toe because candidates lower their guard — they think the problem is easy and skip the fundamentals that interviewers actually grade on.

● Critical Mistakes — Interview Enders

// Interviewer: "Design Tic-Tac-Toe"
// Candidate immediately types...
char[,] board = new char[3, 3];  // no scoping, no clarification
// 5 min later: "Wait, do you need undo?"
// Candidate: *panic rewrite*

// "Before I code: 3x3 or NxN? AI? Undo? Console or GUI-agnostic?"
// Interviewer: "3x3 with undo and AI"
// NOW the candidate knows the full scope before line 1.
// Board is a class (not an array), moves are Commands, AI is a Strategy.

public class TicTacToe // does EVERYTHING
{
    private char[,] _board = new char[3, 3];
    public void PlaceMark(int r, int c) { ... }
    public bool CheckWinner() { ... }         // win logic here
    public void AiMove() { ... }              // AI logic here
    public void PrintBoard() { ... }          // display logic here
    public void Undo() { ... }                // undo logic here
    // 250 more lines...
}

Board          // owns grid + PlaceMark + CheckWinner
Game           // orchestrates turns, delegates to state
IGameState     // each mode's rules (State pattern)
IPlayer        // human vs AI (Strategy via IPlayerStrategy)
IMoveCommand   // undo/redo (Command pattern)
// Each class: one job. Change AI without touching Board.

● Serious Mistakes — Significant Red Flags

public void PlaceMark(int row, int col)
{
    if (_board[row, col] != Mark.Empty)
        throw new InvalidOperationException("Cell occupied!");
    // caller MIGHT forget to catch -- app crashes
}

public Result<GameResult> PlaceMark(int row, int col)
{
    if (_board[row, col] != Mark.Empty)
        return Result.Fail("Cell is already occupied");
    // caller MUST check .IsSuccess -- can't ignore
}

public (int, int) GetHumanMove()
{
    Console.Write("Enter row,col: ");      // hardcoded to console
    var input = Console.ReadLine()!;       // can't test without human
    return Parse(input);
}

public (int, int) GetAiMove()
{
    var random = new Random();             // non-deterministic
    return (random.Next(3), random.Next(3));
}

// IPlayer interface -- tests inject ScriptedPlayer
public interface IPlayer
{
    (int Row, int Col) GetMove(Board board);
}

// AI takes injected Random for deterministic tests
public sealed class RandomStrategy(Random random) : IPlayerStrategy
{
    public (int, int) ChooseMove(Board b, Mark m)
    {
        var empty = b.GetEmptyCells();
        return empty[random.Next(empty.Count)];
    }
}

// Test: new RandomStrategy(new Random(seed: 42)) -- deterministic!

● Minor Mistakes — Missed Opportunities

You just built a Tic-Tac-Toe game from scratch and discovered three design patterns along the way. Now let's lock those patterns into long-term memory. The trick isn't rote repetition — it's anchoring each concept to something vivid. A story, a place, a picture. When you can "see" it, you can recall it.

Memory Palace — Walk Through a Game Room

Imagine walking into a game room with three stations. Each station represents one of the three core patterns. As you walk through, the pattern clicks into place.

The Story Mnemonic — A Game Night

Picture this: You sit down for game night. First, you check the scoreboard on the wall to see who's X and who's O, and whose turn it is — that's State. Then you grab a notebook and write down every move, so if someone bumps the table, you can rewind — that's Command. Finally, you open a playbook and pick your strategy: random moves for beginners, or Minimax for the competitive players — that's Strategy.

Next time you're in an interview and someone says "design a game," ask yourself: Do I need a scoreboard? A notebook? A playbook? The answer to those three questions gives you 90% of the design.

Flashcards — Quiz Yourself

Click each card to reveal the answer. If you can answer without peeking, the pattern is sticking.

Smell → Pattern Quick Reference

5 Things to ALWAYS Mention in a Tic-Tac-Toe Interview

You didn't just learn how to build a game. You learned a set of thinking moves — state management, action recording, and algorithm swapping. Those three ideas appear in virtually every interactive system, from chat apps to banking software. Below is the proof: the exact same three patterns, applied to four different domains. Same skeleton, different skin.

Transfer Web — One Game, Many Domains

Think of Tic-Tac-Toe as the center of a web. Every pattern you learned radiates outward into entirely different systems. The domain changes, but the structural move stays the same.

Same Skeleton, Different Skin

Here's the key insight: the structure of your code doesn't change when the domain changes. An IState interface, a History<ICommand> stack, and an IStrategy injection point look the same whether you're building a board game or a banking app. Only the concrete classes change.

Quick Transfer — Three Concrete Examples

Each card shows a technique from Tic-Tac-Toe dropped into a completely different domain. Same move, different arena.

Five thinking tools you picked up in this case study. Each one is a portable mental move — not a Tic-Tac-Toe trick, but something you can use in any LLD interview or real-world design. Here's what each tool is, when to reach for it, and where you used it in this case study.

Smell → Pattern → When to Use

Five exercises that test whether you truly learned the thinking, not just memorized the code. Each one adds a new constraint that forces you to extend the design — exactly like a real interview follow-up question.

public class Board
{
    public int Size { get; }
    private readonly Mark?[,] _cells;

    public Board(int size = 3)
    {
        Size = size;
        _cells = new Mark?[size, size];
    }

    public bool IsValidMove(int row, int col)
        => row >= 0 && row < Size
        && col >= 0 && col < Size
        && _cells[row, col] is null;
}

// WinChecker now uses Size instead of hardcoded 3
public bool CheckLine(Board board, int startR, int startC,
    int dR, int dC, Mark mark)
{
    for (int i = 0; i < board.Size; i++)
        if (board[startR + i * dR, startC + i * dC] != mark)
            return false;
    return true;
}

public class GameReplay
{
    private readonly IReadOnlyList<ICommand> _moves;

    public GameReplay(IReadOnlyList<ICommand> moves)
        => _moves = moves;

    public async IAsyncEnumerable<Board> ReplayAsync(
        Board freshBoard,
        TimeSpan delay)
    {
        yield return freshBoard; // show empty board first

        foreach (var move in _moves)
        {
            await Task.Delay(delay);
            move.Execute(freshBoard);
            yield return freshBoard;
        }
    }
}

// Usage:
var replay = new GameReplay(game.MoveHistory);
await foreach (var snapshot in replay.ReplayAsync(
    new Board(), TimeSpan.FromSeconds(1)))
{
    renderer.Draw(snapshot);
}

// Snapshot = pure data, easy to serialize
public record GameSnapshot(
    int BoardSize,
    Mark?[,] Cells,
    List<MoveData> MoveHistory,
    Mark CurrentTurn,
    string AiDifficulty);

public record MoveData(int Row, int Col, Mark Player);

// Interface for persistence (Strategy pattern!)
public interface IGamePersistence
{
    Task SaveAsync(GameSnapshot snapshot, string path);
    Task<GameSnapshot> LoadAsync(string path);
}

// JSON implementation
public class JsonGamePersistence : IGamePersistence
{
    public async Task SaveAsync(GameSnapshot snap, string path)
        => await File.WriteAllTextAsync(path,
            JsonSerializer.Serialize(snap));

    public async Task<GameSnapshot> LoadAsync(string path)
        => JsonSerializer.Deserialize<GameSnapshot>(
            await File.ReadAllTextAsync(path))!;
}

public interface IGameObserver
{
    void OnMoveMade(MoveData move, Board boardSnapshot);
    void OnGameOver(GameResult result);
}

public class Game
{
    private readonly List<IGameObserver> _observers = [];

    public void AddSpectator(IGameObserver spectator)
        => _observers.Add(spectator);

    public void RemoveSpectator(IGameObserver spectator)
        => _observers.Remove(spectator);

    private void NotifyAll(MoveData move)
    {
        var snapshot = _board.Clone(); // read-only copy
        foreach (var obs in _observers)
            obs.OnMoveMade(move, snapshot);
    }

    public void MakeMove(int row, int col)
    {
        // ... existing move logic ...
        var move = new MoveData(row, col, currentPlayer);
        NotifyAll(move);
    }
}

// A spectator that logs to console
public class ConsoleSpectator(string name) : IGameObserver
{
    public void OnMoveMade(MoveData m, Board b)
        => Console.WriteLine(
            $"[{name}] {m.Player} placed at ({m.Row},{m.Col})");

    public void OnGameOver(GameResult r)
        => Console.WriteLine($"[{name}] Game over: {r}");
}

public record PlayerProfile(string Name, double Rating);

public interface IRatingStrategy
{
    (double NewWinner, double NewLoser) Calculate(
        double winnerRating, double loserRating);
}

public class EloRating(int kFactor = 32) : IRatingStrategy
{
    public (double, double) Calculate(double w, double l)
    {
        double expected = 1.0 / (1 + Math.Pow(10, (l - w) / 400));
        double newW = w + kFactor * (1 - expected);
        double newL = l + kFactor * (0 - (1 - expected));
        return (newW, newL);
    }
}

public class Match(PlayerProfile p1, PlayerProfile p2)
{
    private readonly List<Game> _games = [];
    public int P1Wins => _games.Count(g => g.Winner == p1);
    public int P2Wins => _games.Count(g => g.Winner == p2);
    public bool IsComplete => P1Wins == 2 || P2Wins == 2;
    public PlayerProfile? Winner =>
        P1Wins == 2 ? p1 : P2Wins == 2 ? p2 : null;
}

public class Tournament(
    List<PlayerProfile> players,
    IRatingStrategy rating)
{
    // Seed by rating, generate bracket, run matches
    // After each match, update ratings via IRatingStrategy
    // Notify observers (leaderboard) via IGameObserver
}

You've discovered patterns, principles, and thinking tools in this case study. Here's where to go next — each page below deepens a specific skill you've already started building.

Patterns Used in This Case Study

Principles Behind the Design

Next Case Studies