Snake & Ladder

Everyone's played Snake & Ladder. A 10×10 board, a die, some snakes that send you tumbling down, and ladders that zoom you up. It takes 5 minutes to play and about 30 lines to code. But what happens when you need 2–6 players taking turns? When the board needs to be configurableDifferent game modes like Classic (fixed snake/ladder positions), Random (generated each game), or Kids (more ladders, fewer snakes). The same game engine should support all of them without code changes. — Classic, Random, Kids mode? When you need to detect snake chains (land on a snake that drops you onto another snake)? When dice must be mockableIn testing, "mockable" means you can replace a real component (like a random die) with a fake one that returns predictable values. If the die always rolls 6, you can test exact board positions without randomness ruining your tests. for testing? That 30-line toy becomes a real design problem hiding 3 design patterns.

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. "Support 2-6 players" is a constraint. "Use the Factory 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 write a single line of code, let's play an actual game of Snake & Ladder. Not on a computer — on a physical board. 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 Snake & Ladder, that means: a single player, a 100-cell board, and a die. Roll the die, add the result to your position, done. No snakes, no ladders, no winning condition. The goal of Level 0 is to get something working — then let the next constraint break it.

Your Internal Monologue

"100 cells... do I need Board[100]? Each cell is just a number. The player's position is just an int from 1 to 100. The board itself doesn't HOLD anything yet — no snakes, no ladders."

"So... position is an integer, roll is Random.Shared.Next(1, 7), new position = old + roll. That's it. Don't over-engineer."

"Wait — what about going past 100? If I'm on 98 and roll a 5... I'd be at 103. That's off the board. I'll just cap it or ignore the move. Actually, let me keep it dead simple for now — no boundary check. Let the next level force me to add it."

// Over-engineered: an array of 100 cells
public class Board
{
    private readonly Cell[] _cells = new Cell[101]; // 1-indexed

    public Board()
    {
        for (int i = 1; i <= 100; i++)
            _cells[i] = new Cell(i);
    }
}

public class Cell
{
    public int Number { get; }
    public Cell(int number) => Number = number;
}

// Each cell is just... a number. The Cell class adds nothing.
// The array adds nothing. Position is still just an int.

// Clean: position is just an integer
public class Game
{
    private int _position = 0;  // 0 = not on board yet

    public int Roll()
    {
        int diceValue = Random.Shared.Next(1, 7);
        _position += diceValue;
        return diceValue;
    }

    public int Position => _position;
}

// Three lines of state. That's the entire game at L0.

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

public sealed class Game
{
    private int _position = 0;  // 0 means "not on the board yet"

    public int Position => _position;

    public int Roll()
    {
        int diceValue = Random.Shared.Next(1, 7); // 1-6 inclusive
        _position += diceValue;
        return diceValue;
    }
}

Let's walk through what each piece does:

• _position — a single integer tracking where the player is. Starts at 0 (off the board). After the first roll, it becomes 1–6.
• Roll() — generates a random number between 1 and 6 using Random.SharedA thread-safe, shared instance of Random introduced in .NET 6. Before this, creating multiple Random instances could produce identical sequences if created close together in time. Random.Shared solves this elegantly., adds it to the position, and returns the dice value so the caller knows what was rolled.
• Position — a read-only property exposing the current position. External code can read it but can't change it directly — the only way to move is through Roll().

10 lines. It works for a toy game. But can you already spot what's missing? There's no boundary checking (what if position exceeds 100?), no snakes or ladders, no other players, and no win condition. We'll feel each of these pains in the coming levels.

The Board — 100 Cells, Zig-Zag Numbering

How Roll() Works

Growing Diagram — After Level 0

Now we get to add the thing that makes the game interesting — the snakes and ladders themselves. A snake has a head (where you land) and a tail (where you end up). A ladder has a bottom (where you land) and a top (where you climb to). Both are simple mappings: "if you land HERE, teleport to THERE." The question is: how do we represent them in code?

Your Internal Monologue

"A snake has two positions: head (where you land) and tail (where you end up). Does it have behavior? Does a snake DO anything? No — it's just a mapping: position A → position B. Same for ladders. They're data, not behavior."

"Should I use a class Snake with methods? That feels heavy for something with zero behavior. A recordRecords in C# are perfect for data that will never change after creation. A snake at position 97→3 will ALWAYS be 97→3. It's a fact about the board, not something that evolves. is better — it says 'this is pure data, never changes.'"

"And the board... it needs to answer one question: 'I landed on cell X — where do I end up?' That's a DictionaryA Dictionary<int, int> maps keys to values. Here it maps landing positions to destination positions. Cell 97 (snake head) maps to cell 3 (snake tail). Cell 4 (ladder bottom) maps to cell 56 (ladder top). O(1) lookup time.. Build a Dictionary<int, int> from all the snakes and ladders. Lookup is O(1). Clean."

// Over-engineered: inheritance for data-only types
public abstract class BoardEntity
{
    public int Start { get; }
    public int End { get; }
    public abstract string Type { get; }
    public abstract void Apply(Player player);
}

public class Snake : BoardEntity
{
    public override string Type => "Snake";
    public override void Apply(Player p) => p.Position = End;
}

public class Ladder : BoardEntity
{
    public override string Type => "Ladder";
    public override void Apply(Player p) => p.Position = End;
}

// Both Apply() methods do the EXACT same thing.
// The "behavior" is identical. This is a hierarchy for nothing.

// Minimal but loses distinction
var transitions = new Dictionary<int, int>
{
    [97] = 3,   // Is this a snake or a ladder?
    [4] = 56,   // Snake going up? Ladder going down?
    [62] = 19,  // No way to tell from the data alone
};

// Lookup: clean
int destination = transitions.GetValueOrDefault(position, position);

// Problem: you can't tell snakes from ladders.
// Logging "Player hit a snake at 97" is impossible.
// Debugging is harder. Type information is lost.

// Clean: typed records + config class
public readonly record struct Snake(int Head, int Tail);
public readonly record struct Ladder(int Bottom, int Top);

public class BoardConfig
{
    public IReadOnlyList<Snake> Snakes { get; }
    public IReadOnlyList<Ladder> Ladders { get; }
    private readonly Dictionary<int, int> _transitions;

    public BoardConfig(IEnumerable<Snake> snakes, IEnumerable<Ladder> ladders)
    {
        Snakes = snakes.ToList();
        Ladders = ladders.ToList();
        _transitions = new Dictionary<int, int>();
        foreach (var s in Snakes) _transitions[s.Head] = s.Tail;
        foreach (var l in Ladders) _transitions[l.Bottom] = l.Top;
    }

    public int GetDestination(int position)
        => _transitions.TryGetValue(position, out var dest) ? dest : position;
}

Here's Level 1 — the Game class updated to use BoardConfig. Notice how Roll() now checks for snakes and ladders after moving.

/// A snake connects a Head (higher cell) to a Tail (lower cell).
/// When a player lands on the Head, they slide down to the Tail.
/// Immutable — a snake's position never changes during a game.
public readonly record struct Snake(int Head, int Tail);

/// A ladder connects a Bottom (lower cell) to a Top (higher cell).
/// When a player lands on the Bottom, they climb up to the Top.
/// Immutable — a ladder's position never changes during a game.
public readonly record struct Ladder(int Bottom, int Top);

public sealed class BoardConfig
{
    public IReadOnlyList<Snake> Snakes { get; }
    public IReadOnlyList<Ladder> Ladders { get; }
    private readonly Dictionary<int, int> _transitions;

    public BoardConfig(IEnumerable<Snake> snakes, IEnumerable<Ladder> ladders)
    {
        Snakes = snakes.ToList();
        Ladders = ladders.ToList();

        // Build O(1) lookup: position → destination
        _transitions = new Dictionary<int, int>();
        foreach (var s in Snakes)  _transitions[s.Head]   = s.Tail;
        foreach (var l in Ladders) _transitions[l.Bottom] = l.Top;
    }

    /// Resolve ALL transitions (handles chains:
    /// snake drops you onto another snake's head).
    public int Resolve(int position)
    {
        // Keep following transitions until stable
        while (_transitions.TryGetValue(position, out var dest))
            position = dest;
        return position;
    }
}

public sealed class Game
{
    private readonly BoardConfig _board;     // NEW: board config
    private int _position = 0;

    public Game(BoardConfig board) => _board = board;  // NEW

    public int Position => _position;

    public int Roll()
    {
        int diceValue = Random.Shared.Next(1, 7);
        _position += diceValue;
        _position = _board.Resolve(_position);  // NEW: check snakes/ladders
        return diceValue;
    }
}

The Board Comes Alive — Snakes & Ladders

How BoardConfig Holds Everything

Record vs Class — How To Decide

Growing Diagram — After Level 1

This level introduces two challenges at once. First, multiple players — each with their own name and position, taking turns in order. Second, multiple board configurations — Classic boards have fixed snake/ladder positions, Random boards generate them each game, and Kids boards have more ladders and fewer snakes (to keep it fun for younger players). How do you create these different "flavors" of the same game without a constructor that takes 10 parameters?

Your Internal Monologue

"I need Player objects now — each with a name and position. Turn management... a queue? Circular — after the last player, back to the first. Queue<Player>? Hmm, a queue dequeues. I want a circular list, not a FIFO drain."

"And the board varies: Classic has standard snake/ladder positions, Random generates them, Kids has more ladders. I could pass all this to the Game constructor, but that's ugly — new Game(players, snakes, ladders, rules, dice, ...). Ten parameters? No."

"Wait — I'm creating different CONFIGURATIONS of the same thing. Classic game, Random game, Kids game — same structure, different data. That's a FactoryThe Factory pattern is about creating objects. When you find yourself saying "I need to create the same kind of thing but with different configurations," a Factory method encapsulates all that creation logic in one place.. A GameFactory takes a GameSettings record and produces a fully-configured Game. One line to create any variant."

"Actually, is this Factory or Builder? Builder is for step-by-step construction with optional parts. Factory is for 'give me settings, get back a complete object.' Since all games need the same parts (board + players), just configured differently... Factory fits better here."

// Unmaintainable: every option is a parameter
var game = new Game(
    players: new[] { "Alice", "Bob", "Charlie", "Diana" },
    snakes: new[] { new Snake(97, 3), new Snake(62, 19) },
    ladders: new[] { new Ladder(4, 56), new Ladder(21, 82) },
    diceMin: 1,
    diceMax: 6,
    doubleSixBonus: true,
    exactFinish: true,
    maxTurns: 1000
);

// 8 parameters. What if you add "bounceBack" mode?
// 9. "maxChainDepth"? 10. Every new option = every caller changes.

// Valid but overkill for this problem
var game = new GameBuilder()
    .WithPlayers(4)
    .WithBoard("classic")
    .WithDoubleSixBonus(true)
    .WithExactFinish(true)
    .Build();

// Builder shines when:
// 1. Parts are optional (some games need X, others don't)
// 2. Construction order matters
// 3. You need immutability after build
//
// Here? Every game needs the SAME parts.
// The only thing that varies is the DATA, not the STEPS.

// Clean: one line to create any game variant
var settings = new GameSettings(
    PlayerCount: 4,
    BoardType: "classic",
    DoubleSixBonus: true
);

var game = GameFactory.Create(settings);
// Done. Factory knows HOW to build a Classic 4-player game.
// Caller just says WHAT they want.

// Adding "kids" mode? Change GameFactory.
// Every caller stays the same.

Here's the complete Level 2 solution. Five new files, and the Game class evolves to support multiple players.

/// A player in the game. Has a name and a mutable position.
/// Position starts at 0 (off the board) and moves toward 100.
public sealed class Player
{
    public string Name { get; }
    public int Position { get; set; } = 0; // 0 = not on board yet

    public Player(string name) => Name = name;

    public override string ToString() => $"{Name} (pos {Position})";
}

/// Manages turn order. After the last player, wraps back to first.
/// Uses modular arithmetic for circular rotation.
public sealed class PlayerQueue
{
    private readonly List<Player> _players;
    private int _currentIndex = 0;

    public PlayerQueue(IEnumerable<Player> players)
    {
        _players = players.ToList();
        if (_players.Count < 2)
            throw new ArgumentException("Need at least 2 players");
    }

    /// The player whose turn it is right now.
    public Player Current => _players[_currentIndex];

    /// Advance to the next player (wraps around).
    public void NextTurn()
        => _currentIndex = (_currentIndex + 1) % _players.Count;

    public IReadOnlyList<Player> All => _players;
}

/// All the choices needed to create a game.
/// Immutable — once you decide the settings, they don't change.
public record GameSettings(
    int PlayerCount,         // 2-6 players
    string BoardType,        // "classic", "random", "kids"
    bool DoubleSixBonus = false  // roll 6 → extra turn
);

/// Creates fully configured games from settings.
/// All the "how to build it" logic lives HERE, not in callers.
public static class GameFactory
{
    public static Game Create(GameSettings settings)
    {
        // 1. Pick the right board based on settings
        var board = settings.BoardType switch
        {
            "classic" => BoardConfigs.Classic(),
            "random"  => BoardConfigs.Random(),
            "kids"    => BoardConfigs.Kids(),
            _         => BoardConfigs.Classic()
        };

        // 2. Create N players with default names
        var players = Enumerable
            .Range(1, settings.PlayerCount)
            .Select(i => new Player($"Player {i}"))
            .ToList();

        // 3. Assemble and return a ready-to-play game
        return new Game(board, new PlayerQueue(players), settings);
    }
}

/// Predefined board layouts. Each returns a configured BoardConfig.
public static class BoardConfigs
{
    public static BoardConfig Classic() => new(
        snakes: new Snake[]
        {
            new(97, 3), new(62, 19), new(48, 11),
            new(36, 6), new(88, 24), new(95, 56)
        },
        ladders: new Ladder[]
        {
            new(4, 56), new(21, 82), new(28, 76),
            new(43, 77), new(71, 92), new(12, 51)
        }
    );

    public static BoardConfig Random()
    {
        var rng = Random.Shared;
        var snakes = Enumerable.Range(0, 6)
            .Select(_ =>
            {
                int head = rng.Next(20, 99);
                int tail = rng.Next(2, head);
                return new Snake(head, tail);
            }).ToList();

        var ladders = Enumerable.Range(0, 6)
            .Select(_ =>
            {
                int bottom = rng.Next(2, 80);
                int top = rng.Next(bottom + 1, 99);
                return new Ladder(bottom, top);
            }).ToList();

        return new BoardConfig(snakes, ladders);
    }

    public static BoardConfig Kids() => new(
        snakes: new Snake[] { new(48, 11), new(62, 19) },
        ladders: new Ladder[]
        {
            new(4, 56), new(12, 51), new(21, 82),
            new(28, 76), new(43, 77), new(71, 92),
            new(33, 68), new(55, 89), new(9, 45)
        }
    );
}

public sealed class Game
{
    private readonly BoardConfig _board;
    private readonly PlayerQueue _players;     // NEW
    private readonly GameSettings _settings;   // NEW

    public Game(BoardConfig board, PlayerQueue players, GameSettings settings)
    {
        _board = board;
        _players = players;
        _settings = settings;
    }

    public Player CurrentPlayer => _players.Current;  // NEW

    public int Roll()
    {
        var player = _players.Current;
        int diceValue = Random.Shared.Next(1, 7);
        int newPos = player.Position + diceValue;

        // Boundary: can't go past 100
        if (newPos <= 100)
        {
            player.Position = newPos;
            player.Position = _board.Resolve(player.Position);
        }
        // else: stay put (overshoot rule)

        _players.NextTurn();  // NEW: advance to next player
        return diceValue;
    }

    public IReadOnlyList<Player> Players => _players.All;  // NEW
}

Circular Turn Rotation

GameFactory — One Method, Any Variant

Giant Constructor vs Factory

Three Board Types Side by Side

Growing Diagram — After Level 2

Your inner voice:

"Okay, I need the game to behave differently depending on its current mode. In Waiting, rolling should fail. In Playing, adding new players should fail. In Finished, everything should fail except checking who won..."

"My first instinct: add if (state == GameState.Playing) checks to every method. But let me count... 4 states × 5 methods = 20 if/else branches. And when I add Paused? That's 25 branches. Every single method gets touched. That violates OCPThe Open/Closed Principle says a class should be open for extension but closed for modification. You should be able to add new behavior without changing existing code. Adding a new state should mean writing a new class, not editing every existing method.."

"Wait — the behavior depends on state. Each state defines what's allowed and what's blocked. What if each state was its own object that knew its own rules? The game just asks the current state, 'Hey, can I roll?' and the state says yes or no."

"That's the State patternThe State pattern lets an object change its behavior when its internal state changes. Instead of if/else checks, you create separate classes for each state — each defining what's allowed and what happens. The object delegates to its current state, and swapping states swaps behavior entirely.! Each mode becomes its own class. The game holds a reference to the current state. When someone wins, we swap the state object to FinishedState. Adding Paused? Write one new class. Done."

What Would You Do?

Three developers, three ways to handle game modes. Only one survives the "add Paused without touching existing code" test.

public enum GameMode { Waiting, Playing, Finished }

public void Roll()
{
    switch (_mode)
    {
        case GameMode.Waiting:
            throw new InvalidOperationException("Game hasn't started!");
        case GameMode.Playing:
            // actual dice roll logic...
            break;
        case GameMode.Finished:
            throw new InvalidOperationException("Game is over!");
    }
}

public void AddPlayer(string name)
{
    switch (_mode)
    {
        case GameMode.Waiting:
            _players.Add(new Player(name));
            break;
        case GameMode.Playing:
            throw new InvalidOperationException("Can't join mid-game!");
        case GameMode.Finished:
            throw new InvalidOperationException("Game is over!");
    }
}
// ... same pattern for Start(), Pause(), GetWinner()...

private bool _isStarted = false;
private bool _isFinished = false;
private bool _isPaused = false;

public void Roll()
{
    if (!_isStarted)
        throw new InvalidOperationException("Not started!");
    if (_isFinished)
        throw new InvalidOperationException("Already finished!");
    if (_isPaused)
        throw new InvalidOperationException("Game is paused!");

    // actual logic...
}

public void Pause()
{
    if (!_isStarted || _isFinished)
        throw new InvalidOperationException("Can't pause now!");
    if (_isPaused)
        throw new InvalidOperationException("Already paused!");
    _isPaused = true;
}

// The game delegates everything to the current state
public void Roll()      => _currentState.Roll(this);
public void AddPlayer() => _currentState.AddPlayer(this);

// Each state knows its own rules:
// WaitingState.Roll()  → "Not started yet!"
// WaitingState.AddPlayer() → adds the player
// PlayingState.Roll()  → actually rolls dice
// PlayingState.AddPlayer() → "Can't join mid-game!"
// FinishedState.Roll() → "Game is over!"

// Adding Paused? One new class. ZERO changes to existing code.

The Solution

The State patternA behavioral pattern where an object changes its behavior when its internal state changes. Each state is a separate class that defines what's allowed and what happens. The object delegates to whichever state is current. Swapping states swaps behavior completely — no if/else needed. turns each game mode into a self-contained class. The game doesn't ask "what mode am I in?" — it just says "do the thing" and the current state decides what "the thing" means right now.

public interface IGameState
{
    void AddPlayer(Game game, string playerName);
    void Start(Game game);
    void Roll(Game game);
    void Pause(Game game);
    string GetWinner(Game game);
    string Name { get; }
}

public sealed class WaitingState : IGameState
{
    public string Name => "Waiting";

    public void AddPlayer(Game game, string playerName)
    {
        game.Players.Enqueue(new Player(playerName));
        Console.WriteLine($"{playerName} joined! ({game.Players.Count} players)");
    }

    public void Start(Game game)
    {
        if (game.Players.Count < 2)
            throw new InvalidOperationException(
                "Need at least 2 players to start.");
        game.TransitionTo(new PlayingState());
    }

    // These don't make sense in Waiting mode
    public void Roll(Game game)
        => throw new InvalidOperationException(
            "Can't roll — game hasn't started. Call Start() first.");

    public void Pause(Game game)
        => throw new InvalidOperationException(
            "Can't pause — game hasn't started yet.");

    public string GetWinner(Game game)
        => throw new InvalidOperationException(
            "No winner — game hasn't started.");
}

public sealed class PlayingState : IGameState
{
    public string Name => "Playing";

    public void Roll(Game game)
    {
        var player = game.CurrentPlayer;
        int diceValue = Random.Shared.Next(1, 7);
        int newPos = player.Position + diceValue;

        // Board boundary check (Level 5 will refine this)
        if (newPos <= 100)
        {
            player.Position = game.Board.GetDestination(newPos);
            Console.WriteLine(
                $"{player.Name} rolled {diceValue} → position {player.Position}");

            if (player.Position == 100)
            {
                game.Winner = player;
                game.TransitionTo(new FinishedState());
                return;
            }
        }
        game.AdvanceTurn();
    }

    public void Pause(Game game)
        => game.TransitionTo(new PausedState());

    public void AddPlayer(Game game, string playerName)
        => throw new InvalidOperationException(
            "Can't add players mid-game.");

    public void Start(Game game)
        => throw new InvalidOperationException(
            "Game is already running.");

    public string GetWinner(Game game)
        => throw new InvalidOperationException(
            "No winner yet — game is still in progress.");
}

public sealed class FinishedState : IGameState
{
    public string Name => "Finished";

    public string GetWinner(Game game)
        => game.Winner?.Name
            ?? throw new InvalidOperationException("No winner recorded.");

    // Everything else is blocked — the game is over
    public void Roll(Game game)
        => throw new InvalidOperationException(
            $"Game over! {game.Winner?.Name} already won.");

    public void AddPlayer(Game game, string playerName)
        => throw new InvalidOperationException(
            "Game is finished — can't add players.");

    public void Start(Game game)
        => throw new InvalidOperationException(
            "Game already finished. Create a new game to play again.");

    public void Pause(Game game)
        => throw new InvalidOperationException(
            "Can't pause a finished game.");
}

// This entire file was added without modifying a single existing state class.
// That's the OCP in action.

public sealed class PausedState : IGameState
{
    public string Name => "Paused";

    public void Start(Game game)
    {
        // Resume the game — go back to Playing
        Console.WriteLine("Game resumed!");
        game.TransitionTo(new PlayingState());
    }

    public void Roll(Game game)
        => throw new InvalidOperationException(
            "Game is paused. Call Start() to resume.");

    public void AddPlayer(Game game, string playerName)
        => throw new InvalidOperationException(
            "Can't add players while paused.");

    public void Pause(Game game)
        => throw new InvalidOperationException(
            "Game is already paused.");

    public string GetWinner(Game game)
        => throw new InvalidOperationException(
            "No winner — game is paused.");
}

public sealed class Game
{
    private IGameState _currentState;

    public PlayerQueue Players { get; }
    public BoardConfig Board { get; }
    public Player? Winner { get; internal set; }
    public Player CurrentPlayer => Players.Current;

    public Game(BoardConfig board)
    {
        Board = board;
        Players = new PlayerQueue();
        _currentState = new WaitingState(); // Always starts in Waiting
    }

    // Every public method is a one-liner — just ask the current state
    public void AddPlayer(string name) => _currentState.AddPlayer(this, name);
    public void Start()                => _currentState.Start(this);
    public void Roll()                 => _currentState.Roll(this);
    public void Pause()                => _currentState.Pause(this);
    public string GetWinner()          => _currentState.GetWinner(this);

    // State objects call this to change the game's mode
    internal void TransitionTo(IGameState newState)
    {
        Console.WriteLine($"[{_currentState.Name}] → [{newState.Name}]");
        _currentState = newState;
    }

    internal void AdvanceTurn() => Players.Advance();
}

Diagrams

State Machine — How the Game Flows Between Modes

Think of this like a traffic system. Each circle is a mode the game can be in. The arrows show what action causes a transition. You can only follow the arrows — there's no shortcut from Waiting to Finished, for example.

Full Game Flow Through States

Here's a complete game from start to finish. Watch how the state transitions happen automatically — the game class never checks what mode it's in.

Permission Matrix — What Each State Allows

Here's the full truth table. Green means the action works in that state, red means it throws an error. Notice how each column (state) is implemented as a single class — the green cells are the methods with real logic, the red cells are one-line throws.

Growing Diagram — Level 3

Four new pieces join the system: the IGameState interface and its four concrete implementations. The Game class now delegates all behavior to whichever state is current.

Before / After Your Brain

Your inner voice:

"Three dice, same interface. Roll() returns a number. But HOW it calculates that number is different every time. The single die uses one random call. The double die uses two random calls and checks if they match. The rigged die just pops the next number from a queue."

"I could use a switch statement on a DiceType enum... but that's the same mistake we avoided in Level 3 with states. And for testing, I need to inject a dice that returns exactly what I want. If the dice is hardcoded inside PlayingState, I can't swap it."

"Multiple algorithms, same interface. The game doesn't care how the number is generated — it just needs a number. That's the Strategy patternThe Strategy pattern defines a family of algorithms, puts each 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 between different route algorithms on a GPS — fastest, shortest, scenic — the app interface stays the same.. Each dice type becomes its own class implementing IDiceStrategy. The game holds one, uses it, and doesn't care which one it is."

What Would You Do?

Three ideas for adding different dice. Two survive initially, but only one survives the "add a new dice type with zero changes" test.

public int RollDice(DiceType type)
{
    return type switch
    {
        DiceType.Single => Random.Shared.Next(1, 7),
        DiceType.Double => Random.Shared.Next(1, 7) + Random.Shared.Next(1, 7),
        DiceType.Rigged => _riggedQueue.Dequeue(), // how does this get here?!
        _ => throw new ArgumentException("Unknown dice type")
    };
}
// Problem: DiceResult needs IsDouble for bonus turn.
// Now you need ANOTHER switch to check if doubles occurred.
// And where does the rigged queue live? In the game class? Messy.

public class SingleDice
{
    public virtual int Roll() => Random.Shared.Next(1, 7);
}

public class DoubleDice : SingleDice
{
    public override int Roll()
    {
        // A double die IS NOT a single die that rolls twice!
        // It has completely different behavior: two independent rolls,
        // checking for doubles, and returning a combined result.
        int d1 = Random.Shared.Next(1, 7);
        int d2 = Random.Shared.Next(1, 7);
        IsDouble = d1 == d2;
        return d1 + d2;
    }
    public bool IsDouble { get; private set; }
}

// Where does RiggedDice fit?
// RiggedDice : SingleDice? It's not a single die at all!
// The inheritance hierarchy is a lie.

// The game just asks for a result. It doesn't know how.
DiceResult result = _diceStrategy.Roll();
int value = result.Value;
bool isDouble = result.IsDouble;

// Standard game? new SingleDice()
// Variant mode? new DoubleDice()
// Unit test? new RiggedDice(4, 6, 3, 1)

// Adding WeightedDice? One new class. Zero changes anywhere.

The Solution

The Strategy patternA behavioral design pattern that defines a family of algorithms, puts each in its own class, and makes them interchangeable at runtime. The object using the algorithm doesn't know or care which strategy it's running. Think of it like interchangeable batteries — AA, rechargeable, or lithium — the device just needs power. turns each dice type into a pluggable component. The game asks "give me a roll result" and doesn't care whether that result came from random numbers, two dice added together, or a predetermined test sequence.

public interface IDiceStrategy
{
    DiceResult Roll();
}

// The result carries BOTH the total value AND whether doubles occurred.
// This is much richer than returning a plain int.
public readonly record struct DiceResult(int Value, bool IsDouble);

public sealed class SingleDice : IDiceStrategy
{
    public DiceResult Roll()
    {
        int value = Random.Shared.Next(1, 7);
        return new DiceResult(value, IsDouble: false);
        // Single die can never produce doubles
    }
}

public sealed class DoubleDice : IDiceStrategy
{
    public DiceResult Roll()
    {
        int die1 = Random.Shared.Next(1, 7);
        int die2 = Random.Shared.Next(1, 7);

        bool isDouble = die1 == die2;
        int total = die1 + die2;

        Console.WriteLine(
            $"Rolled {die1} + {die2} = {total}"
            + (isDouble ? " DOUBLES!" : ""));

        return new DiceResult(total, isDouble);
        // Range: 2-12, bell curve distribution
        // Doubles probability: 1/6 (six matching pairs out of 36)
    }
}

public sealed class RiggedDice : IDiceStrategy
{
    private readonly Queue<int> _values;

    public RiggedDice(params int[] values)
        => _values = new Queue<int>(values);

    public DiceResult Roll()
    {
        if (_values.Count == 0)
            throw new InvalidOperationException(
                "RiggedDice ran out of values! "
                + "Add more values to the constructor.");

        int value = _values.Dequeue();
        return new DiceResult(value, IsDouble: false);
    }
}

// Usage in tests:
// var dice = new RiggedDice(6, 4, 3, 6, 1);
// First roll = 6, second = 4, third = 3, etc.
// Fully deterministic. Every test run is identical.

public sealed class Game
{
    private IGameState _currentState;
    private readonly IDiceStrategy _dice; // NEW — injected via constructor

    public Game(BoardConfig board, IDiceStrategy dice)
    {
        Board = board;
        _dice = dice;           // Store the strategy
        Players = new PlayerQueue();
        _currentState = new WaitingState();
    }

    // PlayingState now uses this instead of Random.Shared directly:
    internal DiceResult RollDice() => _dice.Roll();

    // Everything else stays exactly the same...
    public void Roll()       => _currentState.Roll(this);
    public void AddPlayer(string name) => _currentState.AddPlayer(this, name);
    // ... etc
}

// Creating games with different dice:
var standard = new Game(board, new SingleDice());
var variant  = new Game(board, new DoubleDice());
var testGame = new Game(board, new RiggedDice(4, 6, 3, 2, 5));

Diagrams

Strategy Fan-Out — One Interface, Three Implementations

The game depends on the interface (the dashed box at the top). Below it, three implementations offer completely different algorithms. The game never sees or cares about which one is active.

Probability Distribution — 1d6 Flat vs. 2d6 Bell Curve

Why does the dice type matter for gameplay? With a single die, every number (1-6) has an equal 16.7% chance. With two dice, 7 is the most likely result and the extremes (2 and 12) are rare. This fundamentally changes the game's speed and strategy.

Plug & Play — Same Game, Different Dice

This is the Strategy pattern's superpower: the Game class is identical in all three cases. Only the dice strategy changes. Production, variant mode, and testing all use the same game code.

Growing Diagram — Level 4

Four new pieces: the IDiceStrategy interface, DiceResult record, and three concrete dice classes. The game now accepts its dice as a constructor parameter.

Before / After Your Brain

Your inner voice:

"Let me walk through each edge case category..."

"Boundary — exact 100 rule. Player at 97, rolls 5 = 102. That's past the finish line. The rule says you have to land exactly on 100. So 102 is invalid... bounce back? 100 - (102 - 100) = 98. The player stays at 97, moves forward to 100, overshoots by 2, bounces back 2 spots to 98. That feels right."

"Recursive — chain resolution. Right now, GetDestination() is called once. But what if the destination is ALSO a snake or ladder? I need to keep resolving until the player lands on a cell with no transition. That's a while loop: while (board.HasTransition(pos)) pos = board.GetDestination(pos);"

"Cycle — this is the scary one. If the chain resolution enters a loop, the while loop runs forever. I need to detect cycles during board creation — reject any board that has a cycle. And as a safety net, add a max-hop guard to the resolution loop."

"Wait — this isn't a pattern. This is the What If? frameworkA systematic approach to finding edge cases: walk through boundary conditions, recursive structures, cycles, and concurrency scenarios. The framework forces you to ask 'what if THIS breaks?' for each category, instead of only testing the happy path.. I'm not reaching for a design pattern. I'm reaching for defensive coding — validation, guards, and result types. The 'happy path only' code smell."

Diagrams

The What If? Framework — Four Quadrants of Edge Cases

Every system has the same four categories of things that can go wrong. By systematically walking through each quadrant, you find bugs that happy-path testing never catches.

What Would You Do?

Three ways to handle these edge cases. One quietly ignores them. One crashes the program. One handles them gracefully with a rich return type.

// Player at 97 rolls 5...
player.Position = 97 + 5; // Position = 102
// 102 doesn't exist on the board. Now what?
// board.GetDestination(102) → IndexOutOfRangeException? null? 0?
// Nobody knows until it happens in production.

// Snake chain at 97→25→3?
player.Position = board.GetDestination(97); // = 25
// Player lands on 25. There's a snake at 25→3.
// But we only checked once. Player stays at 25.
// The second snake is silently ignored.

// Ladder 50→85 + Snake 85→50?
// If we DO resolve chains... infinite loop. Game hangs.
// If we DON'T... second transition is silently ignored.
// Both are bugs. Silent ones — the worst kind.

public void Roll()
{
    int newPos = player.Position + diceValue;

    if (newPos > 100)
        throw new InvalidOperationException(
            $"Overshoot: {newPos} exceeds 100!");
    // But wait — overshooting isn't an ERROR.
    // It's a normal game rule: bounce back.
    // Throwing here forces the caller to wrap in try-catch.
    // And the caller doesn't know if this is a real bug
    // or just a player who rolled too high.
}

public sealed record MoveResult(
    string PlayerName,
    int DiceValue,
    int StartPosition,
    int FinalPosition,
    MoveOutcome Outcome,
    IReadOnlyList<string> Events);

public enum MoveOutcome
{
    Normal,       // Moved to new position, no special events
    Overshoot,    // Bounced back — didn't reach 100
    SnakeHit,     // Landed on snake(s), slid down
    LadderClimb,  // Landed on ladder(s), climbed up
    Won,          // Landed exactly on 100!
    BonusTurn     // Rolled doubles, gets another turn
}

// Usage: caller always gets a clear answer
var result = game.Roll();
// result.Outcome == MoveOutcome.Overshoot
// result.Events == ["Rolled 5 from 97 → 102 → bounce to 98"]
// No exceptions. No guessing. No crashes.

The Solution

Three pieces working together: the exact-100 bounce logic, the chain resolution loop with cycle protection, and the board validator that catches loops before the game even starts.

public static int ApplyBounce(int currentPos, int diceValue)
{
    int target = currentPos + diceValue;

    if (target == 100)
        return 100; // Exact hit — WIN!

    if (target > 100)
    {
        // Overshoot: bounce back from 100
        // At 97, roll 5: target = 102, overshoot = 2, bounce to 98
        int overshoot = target - 100;
        return 100 - overshoot;
    }

    return target; // Normal move
}

// Examples:
// ApplyBounce(97, 3) → 100 (WIN!)
// ApplyBounce(97, 5) → 98  (102 → bounce → 98)
// ApplyBounce(97, 1) → 98  (normal)
// ApplyBounce(99, 1) → 100 (WIN!)
// ApplyBounce(99, 6) → 95  (105 → bounce → 95)

public int ResolvePosition(int pos, BoardConfig board,
    List<string> events)
{
    const int maxHops = 10; // Safety net — no real board needs 10 hops
    var visited = new HashSet<int>();
    int hops = 0;

    while (board.HasTransition(pos))
    {
        // Cycle detection: have we been here before?
        if (!visited.Add(pos))
            throw new InvalidBoardException(
                $"Cycle detected at position {pos}! "
                + "Board validation should have caught this.");

        // Safety: guard against absurdly long chains
        if (++hops > maxHops)
            throw new InvalidBoardException(
                $"Chain exceeded {maxHops} hops from {pos}.");

        int oldPos = pos;
        pos = board.GetDestination(pos);

        // Log the event for MoveResult
        string type = pos < oldPos ? "Snake" : "Ladder";
        events.Add($"{type}: {oldPos} → {pos}");
    }

    return pos;
}

// Example: Snake chain 97→25→3
// Hop 1: pos=97 → visited={97} → dest=25 → "Snake: 97→25"
// Hop 2: pos=25 → visited={97,25} → dest=3 → "Snake: 25→3"
// Hop 3: pos=3 → no transition → return 3
// Events: ["Snake: 97→25", "Snake: 25→3"]

public static class BoardValidator
{
    public static void Validate(BoardConfig board)
    {
        ValidateNoOverlaps(board);
        ValidateNoCycles(board);
        ValidatePositionRange(board);
    }

    private static void ValidateNoCycles(BoardConfig board)
    {
        // For every cell that has a transition, follow the chain
        for (int pos = 1; pos <= 100; pos++)
        {
            if (!board.HasTransition(pos)) continue;

            var visited = new HashSet<int>();
            int current = pos;

            while (board.HasTransition(current))
            {
                if (!visited.Add(current))
                    throw new InvalidBoardException(
                        $"Cycle detected: position {current} "
                        + $"appears in chain starting at {pos}. "
                        + $"Path: {string.Join(" → ", visited)} → {current}");
                current = board.GetDestination(current);
            }
        }
    }

    private static void ValidateNoOverlaps(BoardConfig board)
    {
        // A cell can't be both a snake head AND a ladder bottom
        foreach (var snake in board.Snakes)
            if (board.Ladders.Any(l => l.Bottom == snake.Head))
                throw new InvalidBoardException(
                    $"Position {snake.Head} is both a snake head "
                    + "and a ladder bottom!");
    }

    private static void ValidatePositionRange(BoardConfig board)
    {
        // No snake/ladder can start or end at 1 or 100
        // 1 = start, 100 = win condition
        foreach (var s in board.Snakes)
        {
            if (s.Head <= 1 || s.Head >= 100 || s.Tail < 1)
                throw new InvalidBoardException(
                    $"Snake {s.Head}→{s.Tail} has invalid positions.");
        }
    }
}

public void Roll(Game game)
{
    var player = game.CurrentPlayer;
    var diceResult = game.RollDice();
    var events = new List<string>();
    int startPos = player.Position;

    // Step 1: Apply bounce rule
    int afterBounce = MoveHelper.ApplyBounce(
        player.Position, diceResult.Value);

    bool isOvershoot = afterBounce != player.Position + diceResult.Value
                    && afterBounce != 100;
    if (isOvershoot)
        events.Add($"Overshoot! {player.Position + diceResult.Value}"
            + $" → bounced to {afterBounce}");

    // Step 2: Resolve chains (snakes/ladders)
    int finalPos = MoveHelper.ResolvePosition(
        afterBounce, game.Board, events);

    // Step 3: Update player
    player.Position = finalPos;

    // Step 4: Determine outcome
    MoveOutcome outcome;
    if (finalPos == 100)
        outcome = MoveOutcome.Won;
    else if (isOvershoot)
        outcome = MoveOutcome.Overshoot;
    else if (events.Any(e => e.StartsWith("Snake")))
        outcome = MoveOutcome.SnakeHit;
    else if (events.Any(e => e.StartsWith("Ladder")))
        outcome = MoveOutcome.LadderClimb;
    else if (diceResult.IsDouble)
        outcome = MoveOutcome.BonusTurn;
    else
        outcome = MoveOutcome.Normal;

    // Step 5: Handle game state transitions
    if (outcome == MoveOutcome.Won)
    {
        game.Winner = player;
        game.TransitionTo(new FinishedState());
    }
    else if (outcome != MoveOutcome.BonusTurn)
    {
        game.AdvanceTurn(); // Doubles = same player goes again
    }

    game.LastMove = new MoveResult(
        player.Name, diceResult.Value,
        startPos, finalPos, outcome, events);
}

Exact-100 Bounce — Visual Walkthrough

The player at position 97 rolls a 5. They need exactly 3 more to hit 100, but they rolled 5 — that's 2 too many. The ball bounces off 100 and comes back 2 squares to 98.

Snake Chain Resolution — Multi-Hop Cascade

This is the trickiest edge case. The player lands on a snake, slides down, and lands on another snake. Without chain resolution, the second snake is silently ignored. With it, the player cascades through every transition until they land on a clean cell.

Growing Diagram — Level 5

New pieces: MoveResult record, MoveOutcome enum, BoardValidator, and MoveHelper (bounce + chain resolution). The system now has built-in safety nets.

Before / After Your Brain

Your inner voice:

"We already injected the dice in Level 4. But the board is still created inside the factory. If I want a specific board layout for testing — say, only one snake at position 97 — I need to create the board externally and pass it in."

"Actually, we already pass BoardConfig to the Game constructor. The issue is that GameFactory calls BoardValidator internally, creates the config, and passes it to Game. For tests, I can skip the factory entirely and create a BoardConfig directly."

"Wait, this is the bigger picture: Dependency InjectionDependency Injection (DI) means passing dependencies into a class from the outside rather than the class creating them itself. Instead of 'new SomeDependency()' inside the class, you accept it through the constructor. This lets tests swap in fakes, mocks, or rigged versions.. The Game class should receive ALL its dependencies from outside — the board, the dice, even the validator. Tests create the exact configuration they need. Production uses the factory. The Game doesn't know or care who built its pieces."

"This is where everything clicks. Every pattern we used — State, Strategy, records — they all made the code testable as a side effect. Interfaces for dice? Test with RiggedDice. State pattern? Test each state in isolation. MoveResult? Assert on exact outcomes. DI is the glue that connects all the patterns into a testable whole."

The Solution

No fork for this level — there's really only one right answer for testability: inject everything. The Game accepts its board and dice from outside. Tests create the exact scenario they need. Production uses the factory for convenience.

public sealed class Game
{
    private IGameState _currentState;
    private readonly IDiceStrategy _dice;

    // ALL dependencies injected through constructor
    public Game(BoardConfig board, IDiceStrategy dice)
    {
        Board = board;
        _dice = dice;
        Players = new PlayerQueue();
        _currentState = new WaitingState();
    }

    public BoardConfig Board { get; }
    public PlayerQueue Players { get; }
    public Player CurrentPlayer => Players.Current;
    public Player? Winner { get; internal set; }
    public MoveResult? LastMove { get; internal set; }

    // Public API — delegates to current state
    public void AddPlayer(string name)
        => _currentState.AddPlayer(this, name);
    public void Start()
        => _currentState.Start(this);
    public void Roll()
        => _currentState.Roll(this);
    public void Pause()
        => _currentState.Pause(this);
    public string GetWinner()
        => _currentState.GetWinner(this);

    // Internal — used by states
    internal DiceResult RollDice() => _dice.Roll();
    internal void TransitionTo(IGameState state)
        => _currentState = state;
    internal void AdvanceTurn() => Players.Advance();
}

// Factory for production convenience
public static class GameFactory
{
    public static Game CreateClassic()
    {
        var board = BoardConfigs.Classic();
        BoardValidator.Validate(board);
        return new Game(board, new SingleDice());
    }

    public static Game CreateVariant()
    {
        var board = BoardConfigs.Random();
        BoardValidator.Validate(board);
        return new Game(board, new DoubleDice());
    }
}

[Fact]
public void Player_Rolls6_From94_Wins()
{
    // ARRANGE: empty board (no snakes/ladders), rigged dice
    var board = new BoardConfig(
        snakes: Array.Empty<Snake>(),
        ladders: Array.Empty<Ladder>());

    var dice = new RiggedDice(6);
    var game = new Game(board, dice);

    // Add players, manually set position
    game.AddPlayer("Alice");
    game.AddPlayer("Bob");
    game.Start();
    game.CurrentPlayer.Position = 94; // Cheat for testing

    // ACT
    game.Roll(); // Alice rolls 6: 94 + 6 = 100 = WIN!

    // ASSERT
    Assert.Equal(MoveOutcome.Won, game.LastMove!.Outcome);
    Assert.Equal(100, game.LastMove.FinalPosition);
    Assert.Equal("Alice", game.GetWinner());
}
// This test is 100% deterministic.
// Run it 1000 times, same result every time.
// RiggedDice(6) always returns 6.
// Empty board means no snake/ladder surprises.

[Fact]
public void SnakeChain_ResolvesAllHops()
{
    // ARRANGE: two chained snakes
    var board = new BoardConfig(
        snakes: new[]
        {
            new Snake(Head: 97, Tail: 25),
            new Snake(Head: 25, Tail: 3)
        },
        ladders: Array.Empty<Ladder>());

    var dice = new RiggedDice(2); // 95 + 2 = 97 → snake!
    var game = new Game(board, dice);

    game.AddPlayer("Alice");
    game.AddPlayer("Bob");
    game.Start();
    game.CurrentPlayer.Position = 95;

    // ACT
    game.Roll();

    // ASSERT: landed on 97 → snake to 25 → snake to 3
    Assert.Equal(3, game.LastMove!.FinalPosition);
    Assert.Equal(MoveOutcome.SnakeHit, game.LastMove.Outcome);
    Assert.Contains("Snake: 97", game.LastMove.Events[0]);
    Assert.Contains("Snake: 25", game.LastMove.Events[1]);
}

[Fact]
public void Overshoot_ThenSnake_HandledCorrectly()
{
    // ARRANGE: snake at position 98
    var board = new BoardConfig(
        snakes: new[] { new Snake(Head: 98, Tail: 42) },
        ladders: Array.Empty<Ladder>());

    var dice = new RiggedDice(5); // 97 + 5 = 102 → bounce to 98 → snake!
    var game = new Game(board, dice);

    game.AddPlayer("Alice");
    game.AddPlayer("Bob");
    game.Start();
    game.CurrentPlayer.Position = 97;

    // ACT
    game.Roll();

    // ASSERT: bounced to 98, then hit snake to 42
    Assert.Equal(42, game.LastMove!.FinalPosition);
    // The outcome is SnakeHit (snake is the more "impactful" event)
    Assert.Equal(MoveOutcome.SnakeHit, game.LastMove.Outcome);
}

// The scariest combo: overshoot + chain resolution.
// Without both, this scenario either crashes or gives wrong results.

Diagrams

Dependency Injection Graph — Who Creates What

In production, the factory wires up the Game with a real board and real dice. In tests, the test method creates a custom board and rigged dice. The Game class is identical in both cases — it receives its dependencies and does its job.

Test Anatomy — Create, Control, Verify

Every test follows the same three-step pattern: create a controlled environment, trigger the action, and verify the exact outcome. DI makes step 1 possible. Rich return types (MoveResult) make step 3 precise.

Growing Diagram — Level 6

No new classes in Level 6 — only a new arrangement. The Game constructor is now the sole entry point. Tests and production use the same Game class with different configurations.

Before / After Your Brain

Your inner voice:

"The game needs to announce what happens — 'player moved', 'snake hit', 'player won' — without knowing who's listening. A spectator UI needs to hear those events. A leaderboard service needs to hear them. A replay recorder needs to hear them. But the game shouldn't import or reference any of these."

"If I add _spectatorUI.Update() and _leaderboard.RecordWin() inside the Game class, I'm tightly coupling the game to every listener. Adding a new listener (like an analytics service) means editing the Game class. That's the opposite of what we want."

"The game needs to say 'something happened' and walk away. Anyone who cares subscribes. Anyone who doesn't, doesn't. The game has zero knowledge of its audience. That's the Observer patternThe Observer pattern lets an object (the subject) notify a list of dependents (observers) when something changes, without the subject knowing who the observers are. Think of it like a newspaper subscription: the newspaper publishes, subscribers receive. The newspaper doesn't know or care who reads it.."

"And for the game room concept — lobby, playing, finished — that's the State pattern again! We already know how to do that from Level 3. A GameRoom has its own lifecycle, independent of the Game inside it."

The Solution

Two patterns working together: the Observer patternA behavioral pattern where a subject maintains a list of observers and notifies them automatically when state changes. The subject doesn't know what the observers do with the information — it just broadcasts. Observers subscribe and unsubscribe freely. for event broadcasting and a GameRoom wrapper that manages the lifecycle of online games.

public interface IGameObserver
{
    void OnPlayerMoved(MoveResult result);
    void OnSnakeHit(string playerName, int from, int to);
    void OnLadderClimbed(string playerName, int from, int to);
    void OnPlayerWon(string playerName, int totalTurns);
    void OnGameStarted(IReadOnlyList<string> playerNames);
    void OnGamePaused();
    void OnGameResumed();
}

// Spectator UI: shows moves in real-time
public sealed class SpectatorDisplay : IGameObserver
{
    public void OnPlayerMoved(MoveResult r)
        => Console.WriteLine(
            $"[LIVE] {r.PlayerName} rolled {r.DiceValue}: "
            + $"{r.StartPosition} → {r.FinalPosition}");

    public void OnPlayerWon(string name, int turns)
        => Console.WriteLine($"[LIVE] {name} wins in {turns} turns!");

    // ... other methods: log or ignore
}

// Leaderboard: tracks statistics
public sealed class LeaderboardTracker : IGameObserver
{
    private readonly Dictionary<string, int> _wins = new();

    public void OnPlayerWon(string name, int turns)
    {
        _wins[name] = _wins.GetValueOrDefault(name) + 1;
        Console.WriteLine($"[STATS] {name}: {_wins[name]} total wins");
    }

    public void OnPlayerMoved(MoveResult r) { } // Don't care
    // ... other methods: no-op
}

// Replay Recorder: stores every move for playback
public sealed class ReplayRecorder : IGameObserver
{
    private readonly List<MoveResult> _moves = new();

    public void OnPlayerMoved(MoveResult r)
        => _moves.Add(r);

    public IReadOnlyList<MoveResult> GetReplay() => _moves;

    public void OnPlayerWon(string name, int turns) { }
    // ... other methods: no-op
}

public sealed class GameRoom
{
    public string RoomId { get; }
    public Game? CurrentGame { get; private set; }
    public RoomStatus Status { get; private set; }
    private readonly List<string> _waitingPlayers = new();
    private readonly int _maxPlayers;

    public GameRoom(string roomId, int maxPlayers = 4)
    {
        RoomId = roomId;
        _maxPlayers = maxPlayers;
        Status = RoomStatus.Lobby;
    }

    public void Join(string playerName)
    {
        if (Status != RoomStatus.Lobby)
            throw new InvalidOperationException("Room is not in lobby.");
        if (_waitingPlayers.Count >= _maxPlayers)
            throw new InvalidOperationException("Room is full.");

        _waitingPlayers.Add(playerName);
    }

    public void StartGame(BoardConfig board, IDiceStrategy dice)
    {
        if (_waitingPlayers.Count < 2)
            throw new InvalidOperationException("Need 2+ players.");

        CurrentGame = new Game(board, dice);
        foreach (var name in _waitingPlayers)
            CurrentGame.AddPlayer(name);
        CurrentGame.Start();
        Status = RoomStatus.Playing;
    }
}

public enum RoomStatus { Lobby, Playing, Finished }

public sealed class Game
{
    private readonly List<IGameObserver> _observers = new();

    // Subscribe/unsubscribe
    public void AddObserver(IGameObserver observer)
        => _observers.Add(observer);
    public void RemoveObserver(IGameObserver observer)
        => _observers.Remove(observer);

    // Notify all observers (called by states after actions)
    internal void NotifyMoved(MoveResult result)
    {
        foreach (var obs in _observers)
            obs.OnPlayerMoved(result);

        // Fire specific events based on outcome
        foreach (var evt in result.Events)
        {
            if (evt.StartsWith("Snake"))
                foreach (var obs in _observers)
                    obs.OnSnakeHit(result.PlayerName,
                        result.StartPosition, result.FinalPosition);
            else if (evt.StartsWith("Ladder"))
                foreach (var obs in _observers)
                    obs.OnLadderClimbed(result.PlayerName,
                        result.StartPosition, result.FinalPosition);
        }
    }

    internal void NotifyWon(string playerName, int totalTurns)
    {
        foreach (var obs in _observers)
            obs.OnPlayerWon(playerName, totalTurns);
    }

    // ... rest of Game unchanged
}

// Wiring it all together:
var game = new Game(board, dice);
game.AddObserver(new SpectatorDisplay());
game.AddObserver(new LeaderboardTracker());
game.AddObserver(new ReplayRecorder());
// Game doesn't know what's listening. It just broadcasts.

Diagrams

Game Room Lifecycle

An online game room goes through three phases: players join the lobby, the game runs, and then it's finished. This is the State pattern applied at the room level, wrapping the game-level states we built in Level 3.

Observer Broadcasting — Game Emits, Everyone Listens

The game is like a radio station. It broadcasts events. Spectators, the leaderboard, and the replay recorder are all tuned in. The game doesn't know who's listening — it just sends the signal.

Growing Diagram — Level 7 (Final)

The final system diagram. Five new pieces: IGameObserver interface, three concrete observers, and GameRoom. The complete system has 27 types — each with a clear purpose, each introduced by a specific constraint.

Before / After Your Brain

Seven levels. One constraint at a time. And now the whole system is ready to see in one place. Every file below is the final, production-ready version — incorporating every pattern, every edge case, and every refinement we discovered along the way.

Before diving into the code, here's a bird's-eye view of every type in the system. Green types appeared in the foundation levels (L0–L1), yellow ones arrived with the patterns (L2–L4), and red ones came in during the advanced levels (L5–L7). 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, dice strategies in a third. Click through the tabs to read each file.

namespace SnakeAndLadder.Models;

// ─── Snake ────────────────────────────────────────────
// A snake lives on a specific cell (its head) and sends you
// sliding down to a lower cell (its tail). Records give us
// value equality for free — two Snakes at the same positions
// are considered equal without writing custom Equals().
public record Snake(int Head, int Tail);                     // Level 1

// ─── Ladder ───────────────────────────────────────────
// A ladder sits at its bottom cell and lifts you up to its
// top cell. Same immutable record approach as Snake.
public record Ladder(int Bottom, int Top);                   // Level 1

// ─── BoardConfig ──────────────────────────────────────
// Holds the complete layout of one board: which cells have
// snakes, which have ladders, and the board size. The
// GetDestination() method is the single place that answers
// "if I land on cell X, where do I actually end up?"
public sealed class BoardConfig                              // Level 1
{
    public int Size { get; }
    public IReadOnlyList<Snake> Snakes { get; }
    public IReadOnlyList<Ladder> Ladders { get; }

    private readonly Dictionary<int, int> _redirects;

    public BoardConfig(int size,
        IEnumerable<Snake> snakes,
        IEnumerable<Ladder> ladders)
    {
        Size = size;
        Snakes = snakes.ToList().AsReadOnly();
        Ladders = ladders.ToList().AsReadOnly();
        _redirects = new Dictionary<int, int>();

        foreach (var s in Snakes) _redirects[s.Head] = s.Tail;
        foreach (var l in Ladders) _redirects[l.Bottom] = l.Top;
    }

    // One lookup handles both snakes AND ladders.
    // If the cell has no redirect, you stay where you are.
    public int GetDestination(int position) =>               // Level 1
        _redirects.TryGetValue(position, out var dest)
            ? dest : position;
}

// ─── Player ───────────────────────────────────────────
// Each player has a name and a current position on the board.
// Position starts at 0 (off-board) and the goal is to reach
// exactly boardSize (e.g., 100).
public sealed class Player                                   // Level 2
{
    public string Name { get; }
    public int Position { get; set; }

    public Player(string name) => (Name, Position) = (name, 0);

    public override string ToString() => $"{Name} @ {Position}";
}

// ─── PlayerQueue ──────────────────────────────────────
// A circular turn manager. After the last player rolls,
// it wraps back to the first player. This keeps turn logic
// out of the Game class (SRP).
public sealed class PlayerQueue                              // Level 2
{
    private readonly List<Player> _players;
    private int _currentIndex;

    public PlayerQueue(IEnumerable<Player> players)
    {
        _players = players.ToList();
        _currentIndex = 0;
    }

    public Player Current => _players[_currentIndex];
    public int Count => _players.Count;

    public Player Advance()                                  // Level 2
    {
        _currentIndex = (_currentIndex + 1) % _players.Count;
        return Current;
    }

    public void Reset() => _currentIndex = 0;
}

// ─── GameSettings ─────────────────────────────────────
// Configuration record: how many players, which board preset,
// and which dice strategy. Immutable — once a game starts,
// the rules don't change mid-game.
public record GameSettings(                                  // Level 2
    int PlayerCount,
    string BoardPreset,
    string DiceType
);

// ─── DiceResult ───────────────────────────────────────
// What the dice produced: the individual values (for display)
// and the total. Immutable record — a roll can never change.
public record DiceResult(                                    // Level 4
    IReadOnlyList<int> Values,
    int Total
);

// ─── MoveResult ───────────────────────────────────────
// The outcome of a single move: where the player started,
// where they landed after the dice, where they ended up
// after snake/ladder resolution, and whether it was a
// winning move. This replaces scattered Console.WriteLines
// with structured data that any UI can consume.
public record MoveResult(                                    // Level 5
    string PlayerName,
    int StartPosition,
    int DiceTotal,
    int LandedOn,
    int FinalPosition,
    bool WasSnakeBite,
    bool WasLadderClimb,
    bool WasBounce,
    bool IsWin
);

// ─── GameEvent records ────────────────────────────────
// Events that the game fires when interesting things happen.
// Observers subscribe to these without the game knowing
// who's listening. Each event is an immutable record.
public record GameStartedEvent(                              // Level 7
    IReadOnlyList<string> PlayerNames,
    int BoardSize
);
public record TurnStartedEvent(string PlayerName, int Position);
public record DiceRolledEvent(string PlayerName, DiceResult Result);
public record PlayerMovedEvent(MoveResult Result);
public record GameOverEvent(string WinnerName, int TotalTurns);

namespace SnakeAndLadder.States;

// ─── IGameState ───────────────────────────────────────
// The contract every game state must follow. Instead of
// asking "are we in the playing phase?" with boolean flags,
// we let each state object DECIDE what happens when you
// try to roll, start, pause, or resume.
public interface IGameState                                  // Level 3
{
    MoveResult? Roll(Game game);
    void Start(Game game);
    void Pause(Game game);
    void Resume(Game game);
    string Name { get; }
}

// ─── WaitingState ─────────────────────────────────────
// The game has been created but nobody pressed "Start" yet.
// Rolling the dice makes no sense here — we reject it with
// a clear message. Starting transitions us to PlayingState.
public sealed class WaitingState : IGameState                // Level 3
{
    public string Name => "Waiting";

    public MoveResult? Roll(Game game) => null;
    // Can't roll before the game starts — return null

    public void Start(Game game)
    {
        game.TransitionTo(new PlayingState());
        game.NotifyStart();                                  // Level 7
    }

    public void Pause(Game game) { }   // Can't pause if not started
    public void Resume(Game game) { }  // Can't resume if not started
}

// ─── PlayingState ─────────────────────────────────────
// The game is live. This is where all the action happens.
// Rolling the dice moves the current player, checks for
// snakes/ladders, handles the exact-100 bounce rule, and
// advances the turn to the next player.
public sealed class PlayingState : IGameState                // Level 3
{
    public string Name => "Playing";

    public MoveResult? Roll(Game game)
    {
        var player = game.CurrentPlayer;
        var diceResult = game.RollDice();                    // Level 4
        var startPos = player.Position;
        var rawLanding = startPos + diceResult.Total;

        // ── Exact-100 bounce rule ─────────────────────
        // You must land EXACTLY on 100. If the roll takes
        // you past 100, you bounce back by the excess.
        bool wasBounce = false;                              // Level 5
        if (rawLanding > game.BoardSize)
        {
            rawLanding = game.BoardSize - (rawLanding - game.BoardSize);
            wasBounce = true;
        }

        // ── Snake chain resolution ────────────────────
        // If you land on a snake's head, you slide down.
        // But what if the tail lands on ANOTHER snake?
        // We loop until there's no more redirect.
        int finalPos = rawLanding;                           // Level 5
        bool wasSnake = false, wasLadder = false;
        int safetyCounter = 0;
        while (safetyCounter++ < 50)
        {
            int dest = game.Board.GetDestination(finalPos);
            if (dest == finalPos) break;
            if (dest < finalPos) wasSnake = true;
            if (dest > finalPos) wasLadder = true;
            finalPos = dest;
        }

        player.Position = finalPos;
        bool isWin = finalPos == game.BoardSize;

        var result = new MoveResult(
            player.Name, startPos, diceResult.Total,
            rawLanding, finalPos, wasSnake, wasLadder,
            wasBounce, isWin
        );

        game.NotifyMove(result);                             // Level 7

        if (isWin)
        {
            game.TransitionTo(new FinishedState(player.Name));
            return result;
        }

        game.AdvanceTurn();
        return result;
    }

    public void Start(Game game) { }   // Already started
    public void Pause(Game game) =>
        game.TransitionTo(new PausedState());
    public void Resume(Game game) { }  // Already playing
}

// ─── FinishedState ────────────────────────────────────
// Someone reached exactly 100. The game is over. Any further
// rolls are rejected. This state is a dead end — once you're
// here, you can't go back.
public sealed class FinishedState : IGameState               // Level 3
{
    public string WinnerName { get; }
    public string Name => "Finished";

    public FinishedState(string winnerName) =>
        WinnerName = winnerName;

    public MoveResult? Roll(Game game) => null;
    public void Start(Game game) { }
    public void Pause(Game game) { }
    public void Resume(Game game) { }
}

// ─── PausedState ──────────────────────────────────────
// The game is temporarily suspended. Rolling is blocked
// but Resume() brings it back to PlayingState. This is
// essentially a Null Object — it absorbs actions silently
// instead of throwing exceptions.
public sealed class PausedState : IGameState                 // Level 3
{
    public string Name => "Paused";

    public MoveResult? Roll(Game game) => null;
    public void Start(Game game) { }
    public void Pause(Game game) { }   // Already paused
    public void Resume(Game game) =>
        game.TransitionTo(new PlayingState());
}

namespace SnakeAndLadder.Dice;

// ─── IDiceStrategy ────────────────────────────────────
// The contract: "give me a dice result." The game doesn't
// care HOW the result is produced — single die, double dice,
// or a rigged test die. All it needs is a DiceResult.
public interface IDiceStrategy                               // Level 4
{
    DiceResult Roll();
}

// ─── SingleDice ───────────────────────────────────────
// Classic Snake & Ladder: one six-sided die.
// Produces values from 1 to 6.
public sealed class SingleDice : IDiceStrategy               // Level 4
{
    private readonly Random _rng;

    public SingleDice(Random? rng = null)
        => _rng = rng ?? Random.Shared;                     // Level 6

    public DiceResult Roll()
    {
        var value = _rng.Next(1, 7);
        return new DiceResult(new[] { value }, value);
    }
}

// ─── DoubleDice ───────────────────────────────────────
// Party variant: two dice, values added together.
// Produces values from 2 to 12. Some house rules give
// an extra turn on doubles.
public sealed class DoubleDice : IDiceStrategy               // Level 4
{
    private readonly Random _rng;

    public DoubleDice(Random? rng = null)
        => _rng = rng ?? Random.Shared;

    public DiceResult Roll()
    {
        var d1 = _rng.Next(1, 7);
        var d2 = _rng.Next(1, 7);
        return new DiceResult(new[] { d1, d2 }, d1 + d2);
    }
}

// ─── RiggedDice ───────────────────────────────────────
// For testing: you feed it a sequence of predetermined
// results. The game doesn't know the difference — it just
// calls Roll() and gets a DiceResult. This is the beauty
// of the Strategy pattern: testability comes for free.
public sealed class RiggedDice : IDiceStrategy               // Level 4
{
    private readonly Queue<int> _values;

    public RiggedDice(IEnumerable<int> values)
        => _values = new Queue<int>(values);

    public DiceResult Roll()
    {
        if (_values.Count == 0)
            throw new InvalidOperationException(
                "RiggedDice ran out of values");

        var value = _values.Dequeue();
        return new DiceResult(new[] { value }, value);
    }
}

namespace SnakeAndLadder;

// ─── IGameObserver ────────────────────────────────────
// Any external system that wants to know what's happening
// in the game implements this interface. The game fires
// events; observers react. The game never knows WHO is
// listening — it just broadcasts.
public interface IGameObserver                               // Level 7
{
    void OnGameStarted(GameStartedEvent e);
    void OnTurnStarted(TurnStartedEvent e);
    void OnDiceRolled(DiceRolledEvent e);
    void OnPlayerMoved(PlayerMovedEvent e);
    void OnGameOver(GameOverEvent e);
}

// ─── Game ─────────────────────────────────────────────
// The central orchestrator. It doesn't know how dice work
// (Strategy), doesn't know what behavior its current phase
// allows (State), doesn't know who's watching (Observer),
// and doesn't know how the board was built (Factory).
// It just coordinates.
public sealed class Game                                     // Level 0
{
    private IGameState _state;
    private readonly IDiceStrategy _dice;                    // Level 4
    private readonly PlayerQueue _turnQueue;                 // Level 2
    private readonly List<IGameObserver> _observers = new(); // Level 7
    private int _turnCount;

    public BoardConfig Board { get; }                        // Level 1
    public int BoardSize => Board.Size;
    public Player CurrentPlayer => _turnQueue.Current;
    public string StateName => _state.Name;

    public Game(
        BoardConfig board,
        IEnumerable<Player> players,
        IDiceStrategy dice)                                  // Level 4
    {
        Board = board ?? throw new ArgumentNullException(nameof(board));
        _dice = dice ?? throw new ArgumentNullException(nameof(dice));
        _turnQueue = new PlayerQueue(players);
        _state = new WaitingState();                         // Level 3
    }

    // ── State transitions ────────────────────────────
    public void TransitionTo(IGameState newState)            // Level 3
        => _state = newState;

    public void Start() => _state.Start(this);
    public MoveResult? Roll() => _state.Roll(this);
    public void Pause() => _state.Pause(this);
    public void Resume() => _state.Resume(this);

    // ── Dice (delegated to Strategy) ─────────────────
    internal DiceResult RollDice() => _dice.Roll();          // Level 4

    // ── Turn management ──────────────────────────────
    internal void AdvanceTurn()                               // Level 2
    {
        _turnQueue.Advance();
        _turnCount++;
    }

    // ── Observer notifications ───────────────────────
    public void AddObserver(IGameObserver observer)           // Level 7
        => _observers.Add(observer);

    public void RemoveObserver(IGameObserver observer)
        => _observers.Remove(observer);

    internal void NotifyStart()
    {
        var names = Enumerable.Range(0, _turnQueue.Count)
            .Select(_ => { var p = _turnQueue.Current;
                _turnQueue.Advance(); return p.Name; })
            .ToList().AsReadOnly();
        _turnQueue.Reset();
        var e = new GameStartedEvent(names, BoardSize);
        foreach (var obs in _observers) obs.OnGameStarted(e);
    }

    internal void NotifyMove(MoveResult result)
    {
        foreach (var obs in _observers) obs.OnPlayerMoved(
            new PlayerMovedEvent(result));
        if (result.IsWin)
            foreach (var obs in _observers) obs.OnGameOver(
                new GameOverEvent(result.PlayerName, _turnCount));
    }
}

// ─── BoardValidator ───────────────────────────────────
// Catches impossible boards BEFORE the game starts.
// Checks for: snake head == ladder bottom on same cell,
// cycles (snake → ladder → snake loop), out-of-range
// positions, and head/bottom at cell 1 or 100.
public static class BoardValidator                           // Level 5
{
    public static IReadOnlyList<string> Validate(BoardConfig board)
    {
        var errors = new List<string>();
        var redirects = new Dictionary<int, int>();

        foreach (var s in board.Snakes)
        {
            if (s.Head <= 0 || s.Head >= board.Size)
                errors.Add($"Snake head {s.Head} out of range");
            if (s.Tail <= 0 || s.Tail >= s.Head)
                errors.Add($"Snake tail {s.Tail} must be < head {s.Head}");
            if (redirects.ContainsKey(s.Head))
                errors.Add($"Duplicate at cell {s.Head}");
            redirects[s.Head] = s.Tail;
        }

        foreach (var l in board.Ladders)
        {
            if (l.Bottom <= 0 || l.Bottom >= board.Size)
                errors.Add($"Ladder bottom {l.Bottom} out of range");
            if (l.Top <= l.Bottom || l.Top > board.Size)
                errors.Add($"Ladder top {l.Top} must be > bottom {l.Bottom}");
            if (redirects.ContainsKey(l.Bottom))
                errors.Add($"Duplicate at cell {l.Bottom}");
            redirects[l.Bottom] = l.Top;
        }

        // Cycle detection: follow redirects, max 50 hops
        foreach (var start in redirects.Keys)
        {
            var visited = new HashSet<int>();
            var pos = start;
            while (redirects.TryGetValue(pos, out var next))
            {
                if (!visited.Add(next))
                {
                    errors.Add($"Cycle detected starting at {start}");
                    break;
                }
                pos = next;
            }
        }

        return errors.AsReadOnly();
    }
}

// ─── GameFactory ──────────────────────────────────────
// Builds a fully-configured Game from a GameSettings record.
// The caller doesn't need to know how BoardConfig is built
// or which IDiceStrategy to instantiate.
public static class GameFactory                              // Level 2
{
    public static Game Create(GameSettings settings)
    {
        var board = BoardConfigs.Get(settings.BoardPreset);  // Level 2
        var errors = BoardValidator.Validate(board);         // Level 5
        if (errors.Count > 0)
            throw new InvalidOperationException(
                $"Invalid board: {string.Join("; ", errors)}");

        var players = Enumerable.Range(1, settings.PlayerCount)
            .Select(i => new Player($"Player {i}"))
            .ToList();

        IDiceStrategy dice = settings.DiceType switch        // Level 4
        {
            "single" => new SingleDice(),
            "double" => new DoubleDice(),
            _ => new SingleDice()
        };

        return new Game(board, players, dice);
    }
}

// ─── BoardConfigs ─────────────────────────────────────
// Preset board layouts. Classic is the traditional 100-cell
// board. Kids is a smaller 25-cell version. Random generates
// a new layout each time.
public static class BoardConfigs                             // Level 2
{
    public static BoardConfig Get(string preset) => preset switch
    {
        "classic" => Classic(),
        "kids" => Kids(),
        _ => Classic()
    };

    public static BoardConfig Classic() => new(100,
        snakes: new[]
        {
            new Snake(16, 6), new Snake(47, 26),
            new Snake(49, 11), new Snake(56, 53),
            new Snake(62, 19), new Snake(64, 60),
            new Snake(87, 24), new Snake(93, 73),
            new Snake(95, 75), new Snake(98, 78)
        },
        ladders: new[]
        {
            new Ladder(1, 38), new Ladder(4, 14),
            new Ladder(9, 31), new Ladder(21, 42),
            new Ladder(28, 84), new Ladder(36, 44),
            new Ladder(51, 67), new Ladder(71, 91),
            new Ladder(80, 100)
        }
    );

    public static BoardConfig Kids() => new(25,
        snakes: new[]
        {
            new Snake(14, 7), new Snake(19, 3),
            new Snake(22, 12)
        },
        ladders: new[]
        {
            new Ladder(2, 10), new Ladder(8, 16),
            new Ladder(15, 23)
        }
    );
}

using SnakeAndLadder;
using SnakeAndLadder.Models;
using SnakeAndLadder.States;
using SnakeAndLadder.Dice;

// ─── Console Observer ─────────────────────────────────
// A simple observer that prints game events to the console.
// The game doesn't know this class exists — it just fires
// events to whoever subscribed.
public sealed class ConsoleObserver : IGameObserver          // Level 7
{
    public void OnGameStarted(GameStartedEvent e)
        => Console.WriteLine(
            $"Game started! {e.PlayerNames.Count} players on " +
            $"a {e.BoardSize}-cell board.");

    public void OnTurnStarted(TurnStartedEvent e)
        => Console.WriteLine($"\n{e.PlayerName}'s turn (at {e.Position})");

    public void OnDiceRolled(DiceRolledEvent e)
        => Console.WriteLine($"  Rolled: {e.Result.Total}");

    public void OnPlayerMoved(PlayerMovedEvent e)
    {
        var r = e.Result;
        Console.Write($"  {r.PlayerName}: {r.StartPosition}");

        if (r.WasBounce)
            Console.Write($" -> bounced at 100 -> {r.LandedOn}");
        else
            Console.Write($" -> {r.LandedOn}");

        if (r.WasSnakeBite)
            Console.Write($" -> SNAKE! down to {r.FinalPosition}");
        if (r.WasLadderClimb)
            Console.Write($" -> LADDER! up to {r.FinalPosition}");

        Console.WriteLine();
    }

    public void OnGameOver(GameOverEvent e)
        => Console.WriteLine(
            $"\n*** {e.WinnerName} wins in {e.TotalTurns} turns! ***");
}

// ─── Entry point ──────────────────────────────────────
var settings = new GameSettings(
    PlayerCount: 2,
    BoardPreset: "classic",
    DiceType: "single"
);

var game = GameFactory.Create(settings);                     // Level 2
game.AddObserver(new ConsoleObserver());                     // Level 7
game.Start();                                                // Level 3

// Play until someone wins
while (game.StateName == "Playing")                          // Level 3
{
    var result = game.Roll();
    if (result is null) break;
}

Console.WriteLine("\nThanks for playing!");

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 State." 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 Four 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. Purple is State, yellow is Strategy, cyan is Observer, and green is Factory. Some types serve multiple patterns — that's normal and healthy.

How the Patterns Talk to Each Other

These four patterns don't work in isolation. They interact in a specific choreography during every turn. Here's the flow: the State decides if a roll is allowed, the Strategy produces a dice result, the game engine processes the move, and the Observer broadcasts what happened. The Factory set all of this up before the first roll.

You've just spent seven levels building a Snake & Ladder game. At Level 0 it was a single class with an int for position. By Level 7, it's a clean architecture with interfacesContracts that define WHAT something does without saying HOW. IGameState, IDiceStrategy, IBoardFactory, and IGameObserver are all interfaces. They let us swap implementations (SingleDice vs DoubleDice) without changing the code that uses them., records, state machines, and event systems. 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 stage below shows what was added at that level. Glowing boxes are new arrivals; dimmed boxes are types that already existed from earlier levels. Pay attention to the growth curve — 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.

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 a diagram of the problem, and demonstrate the fix.

public class SnakeLadderSystem
{
    private int[] positions;
    private string[] names;
    private int currentPlayerIndex;
    private bool gameOver;
    private Dictionary<int, int> snakes = new()
        { {16,6}, {47,26}, {49,11}, {62,19}, {87,24}, {98,78} };
    private Dictionary<int, int> ladders = new()
        { {1,38}, {4,14}, {9,31}, {21,42}, {28,84}, {80,100} };

    public SnakeLadderSystem(string[] playerNames)
    {
        names = playerNames;
        positions = new int[playerNames.Length];
    }

    public void PlayTurn()
    {
        if (gameOver) { Console.WriteLine("Game over!"); return; }

        var roll = new Random().Next(1, 7);
        var player = names[currentPlayerIndex];
        var pos = positions[currentPlayerIndex] + roll;

        Console.WriteLine($"{player} rolled {roll}");

        if (pos > 100) { Console.WriteLine("Bounce!"); pos = 100 - (pos - 100); }
        if (snakes.ContainsKey(pos)) { Console.WriteLine("Snake!"); pos = snakes[pos]; }
        if (ladders.ContainsKey(pos)) { Console.WriteLine("Ladder!"); pos = ladders[pos]; }

        positions[currentPlayerIndex] = pos;
        Console.WriteLine($"{player} is at {pos}");

        if (pos == 100) { gameOver = true; Console.WriteLine($"{player} wins!"); }
        currentPlayerIndex = (currentPlayerIndex + 1) % names.Length;
    }
}

// Board: ONLY layout and redirect lookups
public sealed class BoardConfig
{
    public int GetDestination(int position) => ...;
}

// State: ONLY "is this action allowed right now?"
public interface IGameState
{
    MoveResult? Roll(Game game);
}

// Dice: ONLY producing random values
public interface IDiceStrategy
{
    DiceResult Roll();
}

// Player: ONLY name and position
public sealed class Player
{
    public string Name { get; }
    public int Position { get; set; }
}

// Observer: ONLY notifying external systems
public interface IGameObserver
{
    void OnPlayerMoved(PlayerMovedEvent e);
}

// To roll a single die, you navigate through:
public interface IAbstractBoardCellEntityTransitionFactory { ... }
public interface IBoardCellTransitionStrategyProvider { ... }
public interface IDiceRollValidatorStrategyFactory { ... }
public interface IPlayerMovementTransitionMediator { ... }
public interface ISnakeLadderResolutionChainHandler { ... }
public interface IGameStateTransitionObserverMediator { ... }

public class DefaultBoardCellEntityTransitionFactory
    : IAbstractBoardCellEntityTransitionFactory
{
    private readonly IBoardCellTransitionStrategyProvider _provider;
    private readonly IDiceRollValidatorStrategyFactory _validator;
    private readonly IPlayerMovementTransitionMediator _mediator;
    // ... 200 lines of delegation ...
}

// New developer: "Where does the dice actually roll?"
// Answer: Follow the chain through 6 interfaces and 4 classes.
// Time to find it: 45 minutes.

// Only 5 interfaces — each solves a REAL problem:
public interface IGameState { ... }       // Needed: 4 phases
public interface IDiceStrategy { ... }    // Needed: 3 dice types
public interface IBoardFactory { ... }    // Needed: testable boards
public interface IDiceProvider { ... }    // Needed: injectable dice
public interface IGameObserver { ... }    // Needed: decoupled output

// "Where does the player move?"
// Answer: PlayingState.Roll() — one method, one file.
// Time to find it: 10 seconds.

// Beautiful code — patterns, naming, separation. But...
public sealed class PlayingState : IGameState
{
    public MoveResult? Roll(Game game)
    {
        var dice = game.RollDice();
        var player = game.CurrentPlayer;
        var newPos = player.Position + dice.Total;

        // BUG #1: No bounce! Player goes to 103 on a 100-cell board
        // and is now in an impossible state.
        player.Position = newPos;

        // BUG #2: Only checks ONE redirect. If snake tail lands
        // on another snake, the second one is ignored.
        var dest = game.Board.GetDestination(newPos);
        if (dest != newPos) player.Position = dest;

        // BUG #3: No validation at startup — board could have a
        // snake head AND ladder bottom at the same cell. Or worse,
        // a cycle: snake at 50→30, ladder at 30→50. Infinite loop.

        if (player.Position == game.BoardSize)
            game.TransitionTo(new FinishedState(player.Name));

        game.AdvanceTurn();
        return new MoveResult(player.Name, ...);
    }
}

// Fix #1: Exact-100 bounce
if (rawLanding > game.BoardSize)
{
    rawLanding = game.BoardSize - (rawLanding - game.BoardSize);
    wasBounce = true;
}

// Fix #2: Snake chain resolution with safety counter
int finalPos = rawLanding;
int safetyCounter = 0;
while (safetyCounter++ < 50)
{
    int dest = game.Board.GetDestination(finalPos);
    if (dest == finalPos) break;
    finalPos = dest;
}

// Fix #3: Board validation at creation time
var errors = BoardValidator.Validate(board);
if (errors.Count > 0)
    throw new InvalidOperationException(
        $"Invalid board: {string.Join("; ", errors)}");

public void Move(int diceRoll)
{
    position += diceRoll;

    // Snakes — good luck figuring out which is which
    if (position == 16) position = 6;
    if (position == 47) position = 26;
    if (position == 49) position = 11;
    if (position == 56) position = 53;
    if (position == 62) position = 19;
    if (position == 87) position = 24;
    if (position == 93) position = 73;
    if (position == 95) position = 75;
    if (position == 98) position = 78;

    // Ladders — more magic numbers
    if (position == 1) position = 38;
    if (position == 4) position = 14;
    if (position == 9) position = 31;
    if (position == 21) position = 42;
    if (position == 28) position = 84;
    if (position == 80) position = 100;

    // Want a kids board? Copy-paste this entire method
    // and change all the numbers. OCP? Never heard of it.
}

// Board positions are DATA, not code
public sealed class BoardConfig
{
    private readonly Dictionary<int, int> _redirects;

    public BoardConfig(IEnumerable<Snake> snakes,
                       IEnumerable<Ladder> ladders)
    {
        _redirects = new();
        foreach (var s in snakes) _redirects[s.Head] = s.Tail;
        foreach (var l in ladders) _redirects[l.Bottom] = l.Top;
    }

    // ONE line handles every snake AND every ladder
    public int GetDestination(int pos) =>
        _redirects.TryGetValue(pos, out var dest) ? dest : pos;
}

// Want a kids board? Just different data:
BoardConfigs.Kids()  // 25 cells, 3 snakes, 3 ladders
BoardConfigs.Classic() // 100 cells, 10 snakes, 9 ladders

public class Game
{
    private List<Player> players = new();
    // No turn tracking. No current player index. No queue.

    public void Roll(string playerName)
    {
        // ANY player can call this at ANY time
        var player = players.First(p => p.Name == playerName);
        var dice = new Random().Next(1, 7);
        player.Position += dice;

        // No check: is it this player's turn?
        // No check: has someone already won?
        // No check: is this player even in the game?

        // Two players call Roll() at the same millisecond:
        // Both read position = 94
        // Both roll 6
        // Both write position = 100
        // Both think they won. Who actually won? Nobody knows.
    }
}

public sealed class PlayerQueue
{
    private readonly List<Player> _players;
    private int _currentIndex;

    public Player Current => _players[_currentIndex];

    public Player Advance()
    {
        _currentIndex = (_currentIndex + 1) % _players.Count;
        return Current;
    }
}

// Now the Game enforces turn order:
public MoveResult? Roll()
{
    // Only the CURRENT player moves
    var player = _turnQueue.Current;
    // ... process the move ...
    _turnQueue.Advance();  // Next player's turn
    return result;
}

// Caller never picks who rolls — the queue decides.

A candidate submitted this Snake & Ladder implementation as a pull request. It compiles. It runs. It plays 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 SnakeLadderGame                                    // Line 1
{
    private readonly Dictionary<int, int> snakes;               // Line 3
    private readonly Dictionary<int, int> ladders;
    private List<Player> players;
    private int currentPlayer = 0;
    private bool gameOver = false;

    public SnakeLadderGame(Dictionary<int, int> snakes,         // Line 9
        Dictionary<int, int> ladders, List<string> names)
    {
        this.snakes = snakes;
        this.ladders = ladders;
        players = names.Select(n => new Player(n)).ToList();
    }

    public string PlayTurn()                                    // Line 16
    {
        if (gameOver) return "Game over";
        var player = players[currentPlayer];
        var roll = new Random().Next(1, 7);                     // Line 20
        var newPos = player.Position + roll;

        if (newPos > 100) return "Bounce";                      // Line 23
        // Doesn't actually bounce — just skips the turn!

        if (snakes.ContainsKey(newPos))                         // Line 26
            newPos = snakes[newPos];
        if (ladders.ContainsKey(newPos))
            newPos = ladders[newPos];

        player.Position = newPos;

        if (newPos == 100)                                      // Line 32
        {
            gameOver = true;
            return $"{player.Name} wins!";
        }

        currentPlayer = (currentPlayer + 1) % players.Count;   // Line 37
        return $"{player.Name} moved to {newPos}";
    }

    public void Pause() { gameOver = true; }                    // Line 41
    public void Resume() { gameOver = false; }                  // Line 42
    // Pause sets gameOver = true. Resume sets it back.
    // But what about an ACTUAL game-over? Resume would
    // reopen a finished game!
}

Found them? Reveal one at a time:

Snake & Ladder sounds like a children’s game — and that’s exactly the trap. Candidates hear “board game” and think it’s trivial, then get blindsided by chain resolution, loop detection, and snake chains. The interviewers below follow the CREATES structure: Clarify → Requirements → Entities → API → Trade-offs → Edge cases → Scale. Two runs: the polished one and the messy-but-honest one. Both get hired.

Knowing the design and communicating the design are separate skills. You can have a perfect Snake & Ladder architecture in your head and still tank the interview because you mumbled through the pattern justification. The 8 cards below cover the exact moments where phrasing matters most — each with a “Say” and “Don’t Say” so you can hear the difference.

12 questions ranked by difficulty. Each has a “Think” prompt, a solid answer, and the great answer that gets “Strong Hire.” Pay special attention to Q7 — the minimum-moves question is a BFS problem in disguise, and it’s the most impressive answer you can give.

public static int MinimumRolls(Board board)
{
    var visited = new bool[board.Size + 1];
    var queue = new Queue<(int cell, int rolls)>();
    queue.Enqueue((1, 0));
    visited[1] = true;

    while (queue.Count > 0)
    {
        var (cell, rolls) = queue.Dequeue();

        for (int dice = 1; dice <= 6; dice++)
        {
            int next = cell + dice;
            if (next > board.Size) continue;

            // Resolve snakes and ladders
            next = board.ResolveCell(next);

            if (next == board.Size) return rolls + 1;

            if (!visited[next])
            {
                visited[next] = true;
                queue.Enqueue((next, rolls + 1));
            }
        }
    }
    return -1; // unreachable (shouldn't happen with valid board)
}

Every one of these has ended real interviews. Snake & Ladder is particularly dangerous because candidates think it’s trivial — they lower their guard and skip the fundamentals that interviewers actually grade on. The mistakes below are ordered by severity: fatal first, then serious, then minor.

● Fatal Mistakes — Interview Enders

public class SnakeLadderGame  // does EVERYTHING
{
    private int[] _snakes, _ladders, _players;
    public void RollDice() { ... }       // dice logic here
    public void MovePlayer() { ... }     // movement logic here
    public void CheckSnake() { ... }     // snake resolution here
    public void CheckLadder() { ... }    // ladder resolution here
    public bool IsWinner() { ... }       // win detection here
    public void PrintBoard() { ... }     // display logic here
    // 250+ lines growing every feature...
}

Board          // owns snake/ladder map + ResolveCell()
Game           // orchestrates turns, delegates to state
IGameState     // WaitingForPlayers, InProgress, Finished
IDiceStrategy  // StandardDice, RiggedDice, WeightedDice
PlayerQueue    // manages turn order
GameFactory    // builds configured games
// Each class: one job. Change dice without touching Board.

● Serious Mistakes — Red Flags

● Minor Mistakes — Missed Opportunities

Interviewer Scoring Rubric

You just built a Snake & Ladder system from scratch and discovered four 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 the Board

Imagine the Snake & Ladder board itself as your memory palace. Each region of the board maps to a design concept. As you walk from cell 1 to cell 100, you pass through every concept in order — just like the CREATES structure.

Smell → Pattern Quick Reference

Pattern Detection Tree

5 Things to ALWAYS Mention in a Snake & Ladder Interview

Flashcards — Quiz Yourself

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

You didn’t just learn how to build a board game. You learned a set of thinking moves — Factory for complex setup, State for mode-dependent behavior, Strategy for swappable algorithms, and Observer for broadcasting events. Those four ideas appear in virtually every interactive system. Below is the proof: the same four patterns applied to three completely different domains.

Transfer Web — One Game, Many Domains

Pattern Heat Map — Which Patterns Repeat Most?

Six thinking tools you picked up in this case study. Each one is a portable mental move — not a Snake & Ladder trick, but something you can use in any LLD interview or real-world design.

Self-Check — Can You Answer These?

Three 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. Use the thinking process: What entity changes? What varies? What pattern fits?

public interface IPowerUp
{
    string Name { get; }
    MoveResult ModifyMove(MoveContext context, MoveResult result);
}

public class ImmunityShield : IPowerUp
{
    public string Name => "Immunity Shield";

    public MoveResult ModifyMove(MoveContext ctx, MoveResult result)
    {
        // If the player would land on a snake, skip the slide
        if (result.HitSnake)
            return result with { FinalPosition = result.PreSnakePosition,
                                 HitSnake = false,
                                 PowerUpUsed = true };
        return result; // no snake? shield wasn't needed
    }
}

public class DoubleMove : IPowerUp
{
    public string Name => "Double Move";

    public MoveResult ModifyMove(MoveContext ctx, MoveResult result)
    {
        // Double the dice roll BEFORE resolving snakes/ladders
        int doubled = ctx.DiceRoll * 2;
        int newPos = ctx.CurrentPosition + doubled;
        if (newPos > ctx.Board.Size) return result; // overshoot
        return ctx.Board.ResolveMove(newPos);
    }
}

public class BoardValidator
{
    public ValidationResult Validate(BoardConfig config)
    {
        var errors = new List<string>();

        if (HasCycles(config))
            errors.Add("Board has snake-ladder cycles");

        if (HasUnreachableCells(config))
            errors.Add("Some cells are unreachable from cell 1");

        if (CountSnakesNear100(config) > 3)
            errors.Add("Too many snakes near cell 100 (max 3)");

        return errors.Count == 0
            ? ValidationResult.Valid
            : ValidationResult.Invalid(errors);
    }

    private bool HasCycles(BoardConfig config)
    {
        // Build directed graph: each snake/ladder is an edge
        var graph = new Dictionary<int, int>();
        foreach (var s in config.Snakes)
            graph[s.Head] = s.Tail;
        foreach (var l in config.Ladders)
            graph[l.Bottom] = l.Top;

        // DFS cycle detection
        var visited = new HashSet<int>();
        foreach (var start in graph.Keys)
        {
            var current = start;
            var path = new HashSet<int>();
            while (graph.ContainsKey(current))
            {
                if (path.Contains(current)) return true; // cycle!
                path.Add(current);
                current = graph[current];
            }
        }
        return false;
    }
}

public record MinMovesResult(int Rolls, List<int> Path);

public class MinimumMovesCalculator
{
    private readonly Board _board;

    public MinimumMovesCalculator(Board board) => _board = board;

    public MinMovesResult? Calculate()
    {
        int size = _board.Size;
        var visited = new bool[size + 1];
        var parent = new Dictionary<int, int>();
        var dist = new int[size + 1];
        var queue = new Queue<int>();

        queue.Enqueue(1);
        visited[1] = true;
        dist[1] = 0;

        while (queue.Count > 0)
        {
            int cell = queue.Dequeue();

            for (int dice = 1; dice <= 6; dice++)
            {
                int next = cell + dice;
                if (next > size) continue;

                // Resolve snakes and ladders (free teleport)
                next = _board.ResolveCell(next);

                if (next == size) // reached 100!
                {
                    parent[next] = cell;
                    dist[next] = dist[cell] + 1;
                    return new MinMovesResult(
                        dist[next],
                        ReconstructPath(parent, next));
                }

                if (!visited[next])
                {
                    visited[next] = true;
                    parent[next] = cell;
                    dist[next] = dist[cell] + 1;
                    queue.Enqueue(next);
                }
            }
        }

        return null; // cell 100 unreachable
    }

    private List<int> ReconstructPath(
        Dictionary<int, int> parent, int target)
    {
        var path = new List<int>();
        int current = target;
        while (current != 1)
        {
            path.Add(current);
            current = parent[current];
        }
        path.Add(1);
        path.Reverse();
        return path;
    }
}

// Usage:
// var calc = new MinimumMovesCalculator(board);
// var result = calc.Calculate();
// Console.WriteLine($"Minimum: {result.Rolls} rolls");
// Console.WriteLine($"Path: {string.Join(" → ", result.Path)}");

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