System Design (LLD)Case Studies

Chess Game - Low Level Design

LevelAdvanced

Duration120 mins

TopicCase Studies

6 / 6

Complete Design Walkthrough

The Complete Chess Game Design

We have journeyed through requirements analysis, entity identification, move validation, game state management, and design patterns. Now it's time to see the complete picture—how all these pieces fit together into a cohesive, production-ready chess game system.

This page presents the final design through multiple lenses: class diagrams showing static structure, sequence diagrams showing dynamic behavior, and a comprehensive code walkthrough demonstrating the system in action. By the end, you'll have a complete mental model of a professional-grade chess engine design.

What You Will Master

Synthesize all components into a unified design. Understand class relationships through UML diagrams, trace move execution through sequence diagrams, and see the complete API surface of the chess engine. This is the capstone of the chess game case study.

High-Level Architecture

Our chess engine follows a layered architecture with clear separation of concerns:

Layer 1: Domain Core — Pure business logic with no external dependencies

Entities: Game, Board, Piece, Position, Move
Value Objects: Color, PieceType, GameStatus
Patterns: Strategy, Command, Memento

Layer 2: Application Services — Orchestrates use cases

Game lifecycle management
Move validation and execution
Event emission

Layer 3: Integration (External) — Not implemented in core, but designed for

UI adapters (CLI, Web, Mobile)
Persistence (save/load games)
Networking (multiplayer)

Converting Mermaid diagram...

Domain Core Independence

The Domain Core has ZERO dependencies on external systems. It doesn't know about HTTP, databases, or UI frameworks. This makes it testable in isolation, portable across platforms, and focused purely on chess logic.

Complete Class Diagram

The class diagram reveals the static structure of our design. Notice how patterns create clear hierarchies (Strategy for movement, Command for moves) and how the Game acts as the central aggregate root.

Converting Mermaid diagram...

Key Relationships
Relationship	Type	Meaning
Game → Board	Composition	Game owns exactly one Board
Game → Player	Aggregation	Game references two Players
Game → MoveCommand	Dependency	Game creates and executes commands
Board → Piece	Composition	Board contains 0-32 Pieces
Piece → MovementStrategy	Association	Piece delegates to strategy
Piece → Position	Association	Piece has a Position (can change)

Sequence Diagram: Making a Move

The most common operation is making a move. This sequence diagram traces the full flow from user request to state update:

Converting Mermaid diagram...

Key Observations:

Validation before execution — Move is thoroughly validated before any state changes
Strategy delegation — Piece asks its strategy for possible moves
Command creation — Appropriate command type is instantiated
Command execution — Command modifies board (encapsulated)
State update — Turn switches, status recalculated
Event emission — Listeners notified (UI, analytics)

Complete API Surface

The Game class presents a clean public API for all chess operations. External code (UI, networking) interacts only through this interface:

Complete Game API
TypeScript
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
/**
 * Game - Complete Public API
 * 
 * This is the sole entry point for external code.
 * Internal implementation details are hidden.
 */
class Game {
    // ==========================================
    // LIFECYCLE
    // ==========================================
    
    /**
     * Create a new game with two players
     */
    constructor(id: string, whitePlayer: Player, blackPlayer: Player);
    
    /**
     * Initialize the board and start the game
     */
    public start(): void;
    
    /**
     * Get unique game identifier
     */
    public getId(): string;
    
    // ==========================================
    // GAME STATE QUERIES
    // ==========================================
    
    /**
     * Get current game status
     */
    public getStatus(): GameStatus;
    
    /**
     * Get the player whose turn it is
     */
    public getCurrentPlayer(): Player;
    
    /**
     * Get the player waiting for their turn
     */
    public getOpponent(): Player;
    
    /**
     * Get current move number (full moves, starting at 1)
     */
    public getMoveNumber(): number;
    
    /**
     * Check if the game is still active (not terminal)
     */
    public isActive(): boolean;
    
    /**
     * Get board for display (read-only view recommended)
     */
    public getBoard(): Board;
    
    // ==========================================
    // MOVE OPERATIONS
    // ==========================================
    
    /**
     * Execute a move from source to destination
     * @returns Result with success status and move details or error
     */
    public makeMove(
        from: Position, 
        to: Position, 
        promoteTo?: PieceType
    ): MoveResult;
    
    /**
     * Get all legal moves for the piece at the given position
     */
    public getLegalMoves(position: Position): Position[];
    
    /**
     * Get all positions with pieces that can move (current player)
     */
    public getMovablePieces(): Position[];
    
    /**
     * Undo the last move (returns false if no moves to undo)
     */
    public undo(): boolean;
    
    /**
     * Redo a previously undone move
     */
    public redo(): boolean;
    
    /**
     * Check if undo is available
     */
    public canUndo(): boolean;
    
    /**
     * Check if redo is available
     */
    public canRedo(): boolean;
    
    // ==========================================
    // GAME TERMINATION
    // ==========================================
    
    /**
     * Current player resigns
     */
    public resign(color: Color): void;
    
    /**
     * Offer a draw to opponent
     */
    public offerDraw(color: Color): void;
    
    /**
     * Respond to a pending draw offer
     */
    public respondToDrawOffer(color: Color, accept: boolean): void;
    
    /**
     * Claim a draw by rule (threefold repetition or fifty-move)
     */
    public claimDraw(color: Color, reason: 'REPETITION' | 'FIFTY_MOVE'): void;
    
    // ==========================================
    // STATE EXPORT/IMPORT
    // ==========================================
    
    /**
     * Export current position as FEN string
     */
    public toFEN(): string;
    
    /**
     * Export complete game as PGN
     */
    public toPGN(): string;
    
    /**
     * Create a memento of current state
     */
    public createSnapshot(): GameSnapshot;
    
    /**
     * Restore state from a memento
     */
    public restoreFromSnapshot(snapshot: GameSnapshot): void;
    
    /**
     * Load a position from FEN string
     */
    public static fromFEN(fen: string, players: [Player, Player]): Game;
    
    // ==========================================
    // MOVE HISTORY
    // ==========================================
    
    /**
     * Get list of all moves in algebraic notation
     */
    public getMoveHistory(): string[];
    
    /**
     * Get detailed move records
     */
    public getMoveRecords(): MoveRecord[];
    
    /**
     * Get the last move made (or undefined if none)
     */
    public getLastMove(): MoveCommand | undefined;
    
    // ==========================================
    // EVENT SUBSCRIPTION
    // ==========================================
    
    /**
     * Subscribe to game events
     */
    public on(eventType: string, listener: GameEventListener): void;
    
    /**
     * Unsubscribe from game events
     */
    public off(eventType: string, listener: GameEventListener): void;
}

Facade Pattern in Action

The Game class acts as a Facade—providing a simplified interface to the complex subsystem of Board, Pieces, Commands, Strategies, etc. External code never needs to understand the internal complexity; all operations flow through Game's clean API.

Complete Usage Example

Let's see the complete system in action with a realistic usage example—playing a short game with all features:

Complete Game Usage
TypeScript
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
// ======================================
// EXAMPLE: Playing a Chess Game
// ======================================
 
import { Game, Player, Position, PieceType, GameStatus } from './chess';
 
// Create players
const magnus = new Player('p1', 'Magnus', Color.WHITE);
const hikaru = new Player('p2', 'Hikaru', Color.BLACK);
 
// Create and start game
const game = new Game('game-001', magnus, hikaru);
game.start();
 
// Subscribe to events for UI updates
game.on('MOVE_MADE', (event) => {
    console.log(`Move: ${event.move.getNotation()}`);
    console.log(`Position: ${event.fen}`);
});
 
game.on('CHECK', (event) => {
    console.log(`${event.checkedColor} is in check!`);
});
 
game.on('GAME_ENDED', (event) => {
    console.log(`Game over: ${event.status}`);
    console.log(`Winner: ${event.winner}`);
});
 
// Play some moves (Scholar's Mate attempt)
console.log('=== Starting Game ===');
console.log(`${game.getCurrentPlayer().name} to move`);
 
// 1. e4
const move1 = game.makeMove(Position.at('e', 2), Position.at('e', 4));
console.log(`Move result: ${move1.success ? 'OK' : move1.errorMessage}`);
 
// 1... e5
game.makeMove(Position.at('e', 7), Position.at('e', 5));
 
// 2. Bc4 (Bishop to c4)
game.makeMove(Position.at('f', 1), Position.at('c', 4));
 
// 2... Nc6
game.makeMove(Position.at('b', 8), Position.at('c', 6));
 
// 3. Qh5 (Queen to h5, attacking f7)
game.makeMove(Position.at('d', 1), Position.at('h', 5));
 
// Show legal moves for Black (need to defend!)
console.log('=== Black must defend! ===');
const blackMoves = game.getMovablePieces();
console.log(`Black has ${blackMoves.length} pieces that can move`);
 
// 3... Nf6 (defends but blunders)
game.makeMove(Position.at('g', 8), Position.at('f', 6));
 
// 4. Qxf7# (Checkmate!)
const checkmate = game.makeMove(Position.at('h', 5), Position.at('f', 7));
 
console.log('=== Game Status ===');
console.log(`Status: ${game.getStatus()}`);
console.log(`Is Active: ${game.isActive()}`);
 
// Export the game
console.log('\n=== PGN Export ===');
console.log(game.toPGN());
// Output: 1. e4 e5 2. Bc4 Nc6 3. Qh5 Nf6 4. Qxf7#
 
// Save state for later
const snapshot = game.createSnapshot();
console.log('\n=== FEN Position ===');
console.log(snapshot.toFEN());
 
// Demonstrate undo
console.log('\n=== Undo Demo ===');
const newGame = new Game('game-002', magnus, hikaru);
newGame.start();
 
newGame.makeMove(Position.at('e', 2), Position.at('e', 4));
newGame.makeMove(Position.at('e', 7), Position.at('e', 5));
console.log(`After 1. e4 e5: ${newGame.getCurrentPlayer().name}'s turn`);
 
newGame.undo();
console.log(`After undo: ${newGame.getCurrentPlayer().name}'s turn`);
console.log(`Can redo: ${newGame.canRedo()}`);
 
newGame.redo();
console.log(`After redo: ${newGame.getCurrentPlayer().name}'s turn`);
 
// Load a specific position from FEN
console.log('\n=== Load from FEN ===');
const testPosition = Game.fromFEN(
    'r1bqkbnr/pppp1ppp/2n5/4p2Q/2B1P3/8/PPPP1PPP/RNB1K1NR b KQkq - 3 3',
    [magnus, hikaru]
);
console.log(`Loaded position - ${testPosition.getCurrentPlayer().name} to move`);
 
// Check legal moves for the king (it's about to be mated!)
const kingPos = testPosition.getBoard().findKing(Color.BLACK);
const kingMoves = testPosition.getLegalMoves(kingPos);
console.log(`Black King has ${kingMoves.length} legal moves`);

Testing the Design

A well-designed system is a testable system. Our architecture enables comprehensive testing at multiple levels:

Testing Strategy
Test Type	What to Test	How
Unit Tests - Strategies	Each piece's movement logic	Create board positions, verify getPossibleMoves()
Unit Tests - Commands	Move execution and undo	Execute command, verify board state, undo, verify restoration
Unit Tests - Validators	Move validation rules	Test valid/invalid move scenarios for each piece and special move
Unit Tests - State Detection	Check/checkmate/stalemate	Set up positions, verify correct detection
Integration Tests	Game flow	Play through games, verify state transitions
Edge Case Tests	Special positions	En passant timing, castling conditions, promotion
Fuzz Testing	Random move sequences	Generate random legal games, verify no crashes

Example Test Suite
TypeScript
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
describe('Chess Game Engine', () => {
    
    describe('KingMovementStrategy', () => {
        it('should return all 8 directions from center', () => {
            const board = new Board();
            const king = new Piece(PieceType.KING, Color.WHITE, Position.at('e', 4));
            board.placePiece(king, king.getPosition());
            
            const moves = king.getPossibleMoves(board);
            
            expect(moves).toHaveLength(8);
            expect(moves).toContainEqual(Position.at('d', 3));
            expect(moves).toContainEqual(Position.at('f', 5));
        });
        
        it('should not move off board from corner', () => {
            const board = new Board();
            const king = new Piece(PieceType.KING, Color.WHITE, Position.at('a', 1));
            board.placePiece(king, king.getPosition());
            
            const moves = king.getPossibleMoves(board);
            
            expect(moves).toHaveLength(3);
        });
    });
    
    describe('Check Detection', () => {
        it('should detect check from queen', () => {
            const board = new Board();
            board.placePiece(
                new Piece(PieceType.KING, Color.WHITE, Position.at('e', 1)),
                Position.at('e', 1)
            );
            board.placePiece(
                new Piece(PieceType.QUEEN, Color.BLACK, Position.at('e', 8)),
                Position.at('e', 8)
            );
            
            expect(CheckDetector.isInCheck(board, Color.WHITE)).toBe(true);
        });
        
        it('should not detect check when blocked', () => {
            const board = new Board();
            board.placePiece(
                new Piece(PieceType.KING, Color.WHITE, Position.at('e', 1)),
                Position.at('e', 1)
            );
            board.placePiece(
                new Piece(PieceType.QUEEN, Color.BLACK, Position.at('e', 8)),
                Position.at('e', 8)
            );
            board.placePiece(
                new Piece(PieceType.PAWN, Color.WHITE, Position.at('e', 2)),
                Position.at('e', 2)
            );
            
            expect(CheckDetector.isInCheck(board, Color.WHITE)).toBe(false);
        });
    });
    
    describe('Checkmate Detection', () => {
        it('should detect Fool\'s Mate', () => {
            const game = createGame();
            game.start();
            
            game.makeMove(Position.at('f', 2), Position.at('f', 3));
            game.makeMove(Position.at('e', 7), Position.at('e', 5));
            game.makeMove(Position.at('g', 2), Position.at('g', 4));
            game.makeMove(Position.at('d', 8), Position.at('h', 4));
            
            expect(game.getStatus()).toBe(GameStatus.CHECKMATE_BLACK_WINS);
        });
    });
    
    describe('Castling', () => {
        it('should allow kingside castling', () => {
            const game = Game.fromFEN(
                'r3k2r/pppppppp/8/8/8/8/PPPPPPPP/R3K2R w KQkq - 0 1',
                [whitePlayer, blackPlayer]
            );
            
            const result = game.makeMove(Position.at('e', 1), Position.at('g', 1));
            
            expect(result.success).toBe(true);
            expect(game.getBoard().getPieceAt(Position.at('g', 1))?.type)
                .toBe(PieceType.KING);
            expect(game.getBoard().getPieceAt(Position.at('f', 1))?.type)
                .toBe(PieceType.ROOK);
        });
        
        it('should not allow castling through check', () => {
            const game = Game.fromFEN(
                'r3k2r/pppp1ppp/8/4r3/8/8/PPPPPPPP/R3K2R w KQkq - 0 1',
                [whitePlayer, blackPlayer]
            );
            
            const legalMoves = game.getLegalMoves(Position.at('e', 1));
            
            expect(legalMoves).not.toContainEqual(Position.at('g', 1));
        });
    });
    
    describe('Command Undo', () => {
        it('should restore captured piece on undo', () => {
            const game = createGame();
            game.start();
            
            game.makeMove(Position.at('e', 2), Position.at('e', 4));
            game.makeMove(Position.at('d', 7), Position.at('d', 5));
            game.makeMove(Position.at('e', 4), Position.at('d', 5)); // Capture
            
            expect(game.getBoard().getPieceAt(Position.at('d', 5))?.color)
                .toBe(Color.WHITE);
            expect(game.getBoard().getPieceAt(Position.at('d', 7))).toBeNull();
            
            game.undo();
            
            expect(game.getBoard().getPieceAt(Position.at('d', 5))?.color)
                .toBe(Color.BLACK);
            expect(game.getBoard().getPieceAt(Position.at('e', 4))?.color)
                .toBe(Color.WHITE);
        });
    });
});

Extension Points for Future Features

Our design intentionally leaves extension points for features we deferred. Here's how each would integrate:

Extensibility Analysis

•AI Opponent — Implement IPlayer interface with selectMove(game): Promise<Move>. AI analyzes game state, returns best move. No changes to Game needed.
•Chess Variants — Create new MovementStrategy subclasses for fairy pieces. Add variant-specific rules to MoveValidator. Override Board.setupStandardPosition() for initial placement.
•Online Multiplayer — Serialize MoveCommand and send over network. Opponent's client deserializes and executes. Use events for synchronization.
•Persistent Storage — Use GameSnapshot.toFEN() and toPGN() for saving. Game.fromFEN() for loading. Add database adapter in integration layer.
•Time Controls — Add ChessClock component that integrates with Game via events. Modify turn switching to update clock.
•Analysis Mode — Use unlimited undo()/redo() with branching move trees. Store multiple command histories per branch.

Open-Closed Principle in Action

Every extension above adds new code without modifying existing code. This is the Open-Closed Principle: open for extension, closed for modification. The patterns we chose (Strategy, Command, Observer) make this possible.

Summary: The Complete Chess Game Design

We have completed a comprehensive Low-Level Design of a chess game system. Let's consolidate everything we've built:

Design Achievement Summary

•Comprehensive Requirements — Functional (moves, rules, termination), non-functional (performance, extensibility), and clear scope boundaries
•Domain-Rich Entities — Game, Board, Piece hierarchy, Position (value object), Move (command), Player—each with clear responsibilities
•Robust Move Validation — Pseudo-legal and legal move separation, check detection, special move handling (castling, en passant, promotion)
•Complete State Management — State machine for game status, turn alternation, all draw conditions, event-driven updates
•Elegant Pattern Application — Strategy for movement, Command for execution/undo, Memento for snapshots, Observer for events
•Clean Architecture — Layered design with domain core isolated from external concerns
•Extensible Design — Ready for AI, variants, multiplayer, persistence without core modifications

The Bigger Picture:

This chess game design exemplifies how to approach any complex LLD problem:

Understand deeply before designing — Requirements and domain knowledge first
Identify entities from the domain — Not from implementation convenience
Separate concerns cleanly — Each class has one reason to change
Use patterns where they solve problems — Not to showcase pattern knowledge
Design for extension — Anticipate change without over-engineering
Keep the core pure — No external dependencies in domain logic

These principles apply whether you're designing a game, a payment system, or a social network.

Chess Game Case Study Complete! 🎉

Congratulations! You've designed a production-ready chess game engine from scratch. You've mastered requirements analysis, entity modeling, complex rule implementation, state management, and design pattern application. This case study represents the gold standard of Low-Level Design thinking. Apply these principles to your next design challenge!

6 / 6

Loading learning content...

System Design (LLD)Case Studies

Chess Game - Low Level Design

LevelAdvanced

Duration120 mins

TopicCase Studies

6 / 6

Complete Design Walkthrough

The Complete Chess Game Design

What You Will Master

High-Level Architecture

Our chess engine follows a layered architecture with clear separation of concerns:

Layer 1: Domain Core — Pure business logic with no external dependencies

Entities: Game, Board, Piece, Position, Move
Value Objects: Color, PieceType, GameStatus
Patterns: Strategy, Command, Memento

Layer 2: Application Services — Orchestrates use cases

Game lifecycle management
Move validation and execution
Event emission

Layer 3: Integration (External) — Not implemented in core, but designed for

UI adapters (CLI, Web, Mobile)
Persistence (save/load games)
Networking (multiplayer)

Converting Mermaid diagram...

Domain Core Independence

Complete Class Diagram

Converting Mermaid diagram...

Key Relationships
Relationship	Type	Meaning
Game → Board	Composition	Game owns exactly one Board
Game → Player	Aggregation	Game references two Players
Game → MoveCommand	Dependency	Game creates and executes commands
Board → Piece	Composition	Board contains 0-32 Pieces
Piece → MovementStrategy	Association	Piece delegates to strategy
Piece → Position	Association	Piece has a Position (can change)

Sequence Diagram: Making a Move

The most common operation is making a move. This sequence diagram traces the full flow from user request to state update:

Converting Mermaid diagram...

Key Observations:

Validation before execution — Move is thoroughly validated before any state changes
Strategy delegation — Piece asks its strategy for possible moves
Command creation — Appropriate command type is instantiated
Command execution — Command modifies board (encapsulated)
State update — Turn switches, status recalculated
Event emission — Listeners notified (UI, analytics)

Complete API Surface

The Game class presents a clean public API for all chess operations. External code (UI, networking) interacts only through this interface:

Complete Game API
TypeScript
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
/**
 * Game - Complete Public API
 * 
 * This is the sole entry point for external code.
 * Internal implementation details are hidden.
 */
class Game {
    // ==========================================
    // LIFECYCLE
    // ==========================================
    
    /**
     * Create a new game with two players
     */
    constructor(id: string, whitePlayer: Player, blackPlayer: Player);
    
    /**
     * Initialize the board and start the game
     */
    public start(): void;
    
    /**
     * Get unique game identifier
     */
    public getId(): string;
    
    // ==========================================
    // GAME STATE QUERIES
    // ==========================================
    
    /**
     * Get current game status
     */
    public getStatus(): GameStatus;
    
    /**
     * Get the player whose turn it is
     */
    public getCurrentPlayer(): Player;
    
    /**
     * Get the player waiting for their turn
     */
    public getOpponent(): Player;
    
    /**
     * Get current move number (full moves, starting at 1)
     */
    public getMoveNumber(): number;
    
    /**
     * Check if the game is still active (not terminal)
     */
    public isActive(): boolean;
    
    /**
     * Get board for display (read-only view recommended)
     */
    public getBoard(): Board;
    
    // ==========================================
    // MOVE OPERATIONS
    // ==========================================
    
    /**
     * Execute a move from source to destination
     * @returns Result with success status and move details or error
     */
    public makeMove(
        from: Position, 
        to: Position, 
        promoteTo?: PieceType
    ): MoveResult;
    
    /**
     * Get all legal moves for the piece at the given position
     */
    public getLegalMoves(position: Position): Position[];
    
    /**
     * Get all positions with pieces that can move (current player)
     */
    public getMovablePieces(): Position[];
    
    /**
     * Undo the last move (returns false if no moves to undo)
     */
    public undo(): boolean;
    
    /**
     * Redo a previously undone move
     */
    public redo(): boolean;
    
    /**
     * Check if undo is available
     */
    public canUndo(): boolean;
    
    /**
     * Check if redo is available
     */
    public canRedo(): boolean;
    
    // ==========================================
    // GAME TERMINATION
    // ==========================================
    
    /**
     * Current player resigns
     */
    public resign(color: Color): void;
    
    /**
     * Offer a draw to opponent
     */
    public offerDraw(color: Color): void;
    
    /**
     * Respond to a pending draw offer
     */
    public respondToDrawOffer(color: Color, accept: boolean): void;
    
    /**
     * Claim a draw by rule (threefold repetition or fifty-move)
     */
    public claimDraw(color: Color, reason: 'REPETITION' | 'FIFTY_MOVE'): void;
    
    // ==========================================
    // STATE EXPORT/IMPORT
    // ==========================================
    
    /**
     * Export current position as FEN string
     */
    public toFEN(): string;
    
    /**
     * Export complete game as PGN
     */
    public toPGN(): string;
    
    /**
     * Create a memento of current state
     */
    public createSnapshot(): GameSnapshot;
    
    /**
     * Restore state from a memento
     */
    public restoreFromSnapshot(snapshot: GameSnapshot): void;
    
    /**
     * Load a position from FEN string
     */
    public static fromFEN(fen: string, players: [Player, Player]): Game;
    
    // ==========================================
    // MOVE HISTORY
    // ==========================================
    
    /**
     * Get list of all moves in algebraic notation
     */
    public getMoveHistory(): string[];
    
    /**
     * Get detailed move records
     */
    public getMoveRecords(): MoveRecord[];
    
    /**
     * Get the last move made (or undefined if none)
     */
    public getLastMove(): MoveCommand | undefined;
    
    // ==========================================
    // EVENT SUBSCRIPTION
    // ==========================================
    
    /**
     * Subscribe to game events
     */
    public on(eventType: string, listener: GameEventListener): void;
    
    /**
     * Unsubscribe from game events
     */
    public off(eventType: string, listener: GameEventListener): void;
}

Facade Pattern in Action

Complete Usage Example

Let's see the complete system in action with a realistic usage example—playing a short game with all features:

Complete Game Usage
TypeScript
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
// ======================================
// EXAMPLE: Playing a Chess Game
// ======================================
 
import { Game, Player, Position, PieceType, GameStatus } from './chess';
 
// Create players
const magnus = new Player('p1', 'Magnus', Color.WHITE);
const hikaru = new Player('p2', 'Hikaru', Color.BLACK);
 
// Create and start game
const game = new Game('game-001', magnus, hikaru);
game.start();
 
// Subscribe to events for UI updates
game.on('MOVE_MADE', (event) => {
    console.log(`Move: ${event.move.getNotation()}`);
    console.log(`Position: ${event.fen}`);
});
 
game.on('CHECK', (event) => {
    console.log(`${event.checkedColor} is in check!`);
});
 
game.on('GAME_ENDED', (event) => {
    console.log(`Game over: ${event.status}`);
    console.log(`Winner: ${event.winner}`);
});
 
// Play some moves (Scholar's Mate attempt)
console.log('=== Starting Game ===');
console.log(`${game.getCurrentPlayer().name} to move`);
 
// 1. e4
const move1 = game.makeMove(Position.at('e', 2), Position.at('e', 4));
console.log(`Move result: ${move1.success ? 'OK' : move1.errorMessage}`);
 
// 1... e5
game.makeMove(Position.at('e', 7), Position.at('e', 5));
 
// 2. Bc4 (Bishop to c4)
game.makeMove(Position.at('f', 1), Position.at('c', 4));
 
// 2... Nc6
game.makeMove(Position.at('b', 8), Position.at('c', 6));
 
// 3. Qh5 (Queen to h5, attacking f7)
game.makeMove(Position.at('d', 1), Position.at('h', 5));
 
// Show legal moves for Black (need to defend!)
console.log('=== Black must defend! ===');
const blackMoves = game.getMovablePieces();
console.log(`Black has ${blackMoves.length} pieces that can move`);
 
// 3... Nf6 (defends but blunders)
game.makeMove(Position.at('g', 8), Position.at('f', 6));
 
// 4. Qxf7# (Checkmate!)
const checkmate = game.makeMove(Position.at('h', 5), Position.at('f', 7));
 
console.log('=== Game Status ===');
console.log(`Status: ${game.getStatus()}`);
console.log(`Is Active: ${game.isActive()}`);
 
// Export the game
console.log('\n=== PGN Export ===');
console.log(game.toPGN());
// Output: 1. e4 e5 2. Bc4 Nc6 3. Qh5 Nf6 4. Qxf7#
 
// Save state for later
const snapshot = game.createSnapshot();
console.log('\n=== FEN Position ===');
console.log(snapshot.toFEN());
 
// Demonstrate undo
console.log('\n=== Undo Demo ===');
const newGame = new Game('game-002', magnus, hikaru);
newGame.start();
 
newGame.makeMove(Position.at('e', 2), Position.at('e', 4));
newGame.makeMove(Position.at('e', 7), Position.at('e', 5));
console.log(`After 1. e4 e5: ${newGame.getCurrentPlayer().name}'s turn`);
 
newGame.undo();
console.log(`After undo: ${newGame.getCurrentPlayer().name}'s turn`);
console.log(`Can redo: ${newGame.canRedo()}`);
 
newGame.redo();
console.log(`After redo: ${newGame.getCurrentPlayer().name}'s turn`);
 
// Load a specific position from FEN
console.log('\n=== Load from FEN ===');
const testPosition = Game.fromFEN(
    'r1bqkbnr/pppp1ppp/2n5/4p2Q/2B1P3/8/PPPP1PPP/RNB1K1NR b KQkq - 3 3',
    [magnus, hikaru]
);
console.log(`Loaded position - ${testPosition.getCurrentPlayer().name} to move`);
 
// Check legal moves for the king (it's about to be mated!)
const kingPos = testPosition.getBoard().findKing(Color.BLACK);
const kingMoves = testPosition.getLegalMoves(kingPos);
console.log(`Black King has ${kingMoves.length} legal moves`);

Testing the Design

A well-designed system is a testable system. Our architecture enables comprehensive testing at multiple levels:

Testing Strategy
Test Type	What to Test	How
Unit Tests - Strategies	Each piece's movement logic	Create board positions, verify getPossibleMoves()
Unit Tests - Commands	Move execution and undo	Execute command, verify board state, undo, verify restoration
Unit Tests - Validators	Move validation rules	Test valid/invalid move scenarios for each piece and special move
Unit Tests - State Detection	Check/checkmate/stalemate	Set up positions, verify correct detection
Integration Tests	Game flow	Play through games, verify state transitions
Edge Case Tests	Special positions	En passant timing, castling conditions, promotion
Fuzz Testing	Random move sequences	Generate random legal games, verify no crashes

Example Test Suite
TypeScript
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
describe('Chess Game Engine', () => {
    
    describe('KingMovementStrategy', () => {
        it('should return all 8 directions from center', () => {
            const board = new Board();
            const king = new Piece(PieceType.KING, Color.WHITE, Position.at('e', 4));
            board.placePiece(king, king.getPosition());
            
            const moves = king.getPossibleMoves(board);
            
            expect(moves).toHaveLength(8);
            expect(moves).toContainEqual(Position.at('d', 3));
            expect(moves).toContainEqual(Position.at('f', 5));
        });
        
        it('should not move off board from corner', () => {
            const board = new Board();
            const king = new Piece(PieceType.KING, Color.WHITE, Position.at('a', 1));
            board.placePiece(king, king.getPosition());
            
            const moves = king.getPossibleMoves(board);
            
            expect(moves).toHaveLength(3);
        });
    });
    
    describe('Check Detection', () => {
        it('should detect check from queen', () => {
            const board = new Board();
            board.placePiece(
                new Piece(PieceType.KING, Color.WHITE, Position.at('e', 1)),
                Position.at('e', 1)
            );
            board.placePiece(
                new Piece(PieceType.QUEEN, Color.BLACK, Position.at('e', 8)),
                Position.at('e', 8)
            );
            
            expect(CheckDetector.isInCheck(board, Color.WHITE)).toBe(true);
        });
        
        it('should not detect check when blocked', () => {
            const board = new Board();
            board.placePiece(
                new Piece(PieceType.KING, Color.WHITE, Position.at('e', 1)),
                Position.at('e', 1)
            );
            board.placePiece(
                new Piece(PieceType.QUEEN, Color.BLACK, Position.at('e', 8)),
                Position.at('e', 8)
            );
            board.placePiece(
                new Piece(PieceType.PAWN, Color.WHITE, Position.at('e', 2)),
                Position.at('e', 2)
            );
            
            expect(CheckDetector.isInCheck(board, Color.WHITE)).toBe(false);
        });
    });
    
    describe('Checkmate Detection', () => {
        it('should detect Fool\'s Mate', () => {
            const game = createGame();
            game.start();
            
            game.makeMove(Position.at('f', 2), Position.at('f', 3));
            game.makeMove(Position.at('e', 7), Position.at('e', 5));
            game.makeMove(Position.at('g', 2), Position.at('g', 4));
            game.makeMove(Position.at('d', 8), Position.at('h', 4));
            
            expect(game.getStatus()).toBe(GameStatus.CHECKMATE_BLACK_WINS);
        });
    });
    
    describe('Castling', () => {
        it('should allow kingside castling', () => {
            const game = Game.fromFEN(
                'r3k2r/pppppppp/8/8/8/8/PPPPPPPP/R3K2R w KQkq - 0 1',
                [whitePlayer, blackPlayer]
            );
            
            const result = game.makeMove(Position.at('e', 1), Position.at('g', 1));
            
            expect(result.success).toBe(true);
            expect(game.getBoard().getPieceAt(Position.at('g', 1))?.type)
                .toBe(PieceType.KING);
            expect(game.getBoard().getPieceAt(Position.at('f', 1))?.type)
                .toBe(PieceType.ROOK);
        });
        
        it('should not allow castling through check', () => {
            const game = Game.fromFEN(
                'r3k2r/pppp1ppp/8/4r3/8/8/PPPPPPPP/R3K2R w KQkq - 0 1',
                [whitePlayer, blackPlayer]
            );
            
            const legalMoves = game.getLegalMoves(Position.at('e', 1));
            
            expect(legalMoves).not.toContainEqual(Position.at('g', 1));
        });
    });
    
    describe('Command Undo', () => {
        it('should restore captured piece on undo', () => {
            const game = createGame();
            game.start();
            
            game.makeMove(Position.at('e', 2), Position.at('e', 4));
            game.makeMove(Position.at('d', 7), Position.at('d', 5));
            game.makeMove(Position.at('e', 4), Position.at('d', 5)); // Capture
            
            expect(game.getBoard().getPieceAt(Position.at('d', 5))?.color)
                .toBe(Color.WHITE);
            expect(game.getBoard().getPieceAt(Position.at('d', 7))).toBeNull();
            
            game.undo();
            
            expect(game.getBoard().getPieceAt(Position.at('d', 5))?.color)
                .toBe(Color.BLACK);
            expect(game.getBoard().getPieceAt(Position.at('e', 4))?.color)
                .toBe(Color.WHITE);
        });
    });
});

Extension Points for Future Features

Our design intentionally leaves extension points for features we deferred. Here's how each would integrate:

Extensibility Analysis

•AI Opponent — Implement IPlayer interface with selectMove(game): Promise<Move>. AI analyzes game state, returns best move. No changes to Game needed.
•Chess Variants — Create new MovementStrategy subclasses for fairy pieces. Add variant-specific rules to MoveValidator. Override Board.setupStandardPosition() for initial placement.
•Online Multiplayer — Serialize MoveCommand and send over network. Opponent's client deserializes and executes. Use events for synchronization.
•Persistent Storage — Use GameSnapshot.toFEN() and toPGN() for saving. Game.fromFEN() for loading. Add database adapter in integration layer.
•Time Controls — Add ChessClock component that integrates with Game via events. Modify turn switching to update clock.
•Analysis Mode — Use unlimited undo()/redo() with branching move trees. Store multiple command histories per branch.

Open-Closed Principle in Action

Summary: The Complete Chess Game Design

We have completed a comprehensive Low-Level Design of a chess game system. Let's consolidate everything we've built:

Design Achievement Summary

•Comprehensive Requirements — Functional (moves, rules, termination), non-functional (performance, extensibility), and clear scope boundaries
•Domain-Rich Entities — Game, Board, Piece hierarchy, Position (value object), Move (command), Player—each with clear responsibilities
•Robust Move Validation — Pseudo-legal and legal move separation, check detection, special move handling (castling, en passant, promotion)
•Complete State Management — State machine for game status, turn alternation, all draw conditions, event-driven updates
•Elegant Pattern Application — Strategy for movement, Command for execution/undo, Memento for snapshots, Observer for events
•Clean Architecture — Layered design with domain core isolated from external concerns
•Extensible Design — Ready for AI, variants, multiplayer, persistence without core modifications

The Bigger Picture:

This chess game design exemplifies how to approach any complex LLD problem:

Understand deeply before designing — Requirements and domain knowledge first
Identify entities from the domain — Not from implementation convenience
Separate concerns cleanly — Each class has one reason to change
Use patterns where they solve problems — Not to showcase pattern knowledge
Design for extension — Anticipate change without over-engineering
Keep the core pure — No external dependencies in domain logic

These principles apply whether you're designing a game, a payment system, or a social network.

Chess Game Case Study Complete! 🎉

6 / 6