Designing a Chess System with Tournaments

A comprehensive LLD walkthrough integrating Factory, Strategy, Observer, and Singleton patterns

In this blog, we’ll walk through the design of a Chess system that supports tournaments. We’ll start with requirements gathering, discuss the design decisions and patterns to use, simulate an interview-style Q&A, and then gradually build up our code. This step-by-step process demonstrates good coding practices, flexibility, and scalability—all essential in an LLD interview.

Chess LLD UML

---

1. Requirements Gathering

Functional Requirements:

• Chess Game:

  • A game is played between two players.

  • The game consists of a chessboard, pieces (King, Queen, Pawn, etc.), moves, and game status (active, paused, win/draw).

• Tournaments:

  • The system should support multiple tournament types (e.g., Knockout, Round-Robin).

  • Tournaments consist of several games between players.

  • The tournament system should be able to track progress and declare a final winner.

• Notifications:

  • Players should be notified about tournament events (start, match updates, end).

Non-Functional Requirements:

• Scalability & Extensibility:

  • Adding new tournament types or chess pieces should require minimal changes.

• Maintainability:

  • Code should follow SOLID principles (SRP, OCP) and use design patterns to separate concerns.

• Thread Safety:

  • Critical components (like GameManager and TournamentManager) must be singletons to avoid inconsistent states in a multithreaded environment.

---

2. System Overview and Design Decisions

Interview Q&A Example:

Interviewer: “How would you design a system to manage chess games and tournaments?” You: “I would start by defining the core entities such as Chess, Player, Account, ChessBoard, etc. For game management, I’d use a singleton GameManager to ensure that game state is centrally maintained. When it comes to tournaments, I’d use the Factory pattern to create different tournament types, the Strategy pattern to encapsulate tournament rules, and the Observer pattern to notify players about tournament events.”

Interviewer: “Why use these patterns?” You: _“- The Factory Pattern abstracts creation logic for different tournament types, ensuring we follow the Open-Closed Principle.

• The Strategy Pattern lets us interchange tournament rules (knockout, round-robin) without modifying the tournament class.

• The Observer Pattern decouples notification logic, so any changes in tournament state can be easily propagated to interested parties like players.

• Finally, Singleton Pattern ensures that managers (like GameManager and TournamentManager) are globally accessible and maintain a consistent state.”_

---

3. High-Level Architecture

• Core Chess Components:

  • Chess: Manages the game board, players, moves, and game status.

  • Player, Account, Color, Time: Represent user details and game metadata.

  • ChessBoard, Cell, CellPosition, Move: Represent the chessboard and moves.

  • Piece & Concrete Pieces (King, Queen, Pawn, etc.): Define the behavior of chess pieces.

  • PieceFactory: Creates pieces based on type.

• Game Management:

  • GameManager (Singleton): Centralized management of individual chess games.

• Tournament System:

  • TournamentStrategy (Strategy Pattern): Interface for tournament rules.

  • Concrete Strategies: Example stubs such as KnockoutTournament and RoundRobinTournament.

  • TournamentFactory (Factory Pattern): Creates tournaments based on type.

  • Tournament (Uses Strategy & Observer Patterns): Manages tournament lifecycle and notifications.

  • TournamentObserver (Observer Pattern): Interface for receiving tournament notifications.

  • TournamentManager (Singleton): Manages multiple tournaments.

---

4. Code Walkthrough

Below is the complete code covering all components. This is designed to be comprehensive yet high-level so that you can discuss and extend each part during your interview.

---

Chess System Classes

// Chess.java
public class Chess {
    ChessBoard ChessBoard;
    Player[] player;
    Player currentPlayer;
    List<Move> movesList;
    GameStatus GameStatus;

    public boolean playerMove(CellPosition fromPosition, CellPosition toPosition, Piece piece) {
        // Implementation logic goes here
        return true;
    }
    public boolean endGame() {
        // Implementation logic goes here
        return true;
    }
    private void changeTurn() {
        // Logic to change the current player
    }
}

// Player.java
public class Player implements TournamentObserver {
    Account account;
    Color color;
    Time timeLeft;

    public Player(Account account, Color color) {
        this.account = account;
        this.color = color;
    }

    @Override
    public void update(String message) {
        System.out.println("Notification for " + account.userName + ": " + message);
    }
}

// Account.java
public class Account {
    String userName;
    String password;
    String name;
    String email;
    String phone;
    
    public Account(String userName, String password, String name, String email, String phone) {
        this.userName = userName;
        this.password = password;
        this.name = name;
        this.email = email;
        this.phone = phone;
    }
}

// Color.java
public enum Color {
    BLACK, WHITE;
}

// Time.java
public class Time {
    int mins;
    int secs;
}

// GameStatus.java
public enum GameStatus {
    ACTIVE, PAUSED, FORTFEIGHT, BLACK_WIN, WHITE_WIN
}

// ChessBoard.java
import java.util.List;
public class ChessBoard {
    List<List<Cell>> board;

    public void resetBoard() {
        // Reset the board to initial state
    }
    public void updateBoard(Move move) {
        // Update the board with the given move
    }
}

// Cell.java
public class Cell {
    Color color;
    Piece piece;
    CellPosition position;
}

// CellPosition.java
public class CellPosition {
    char ch;
    int i;
    
    public CellPosition(char ch, int i) {
        this.ch = ch;
        this.i = i;
    }
    
    @Override
    public String toString() {
        return "" + ch + i;
    }
}

// Move.java
public class Move {
    Player turn;
    Piece piece;
    Piece killedPiece;
    CellPosition startPosition;
    CellPosition endPosition; 
}

---

Chess Pieces & Factory

// PieceType.java
public enum PieceType {
    PAWN, ROOK, KNIGHT, BISHOP, QUEEN, KING;
}

// Piece.java
import java.util.List;
public abstract class Piece {
    Color color;

    public Piece(Color color) {
        this.color = color;
    }

    public abstract boolean move(CellPosition fromPosition, CellPosition toPosition);
    public abstract List<CellPosition> possibleMoves(CellPosition fromPosition);
    public abstract boolean validate(CellPosition fromPosition, CellPosition toPosition);
}

Concrete classes (only stubs shown for brevity):

// King.java
import java.util.List;
public class King extends Piece {
    public King(Color color) {
        super(color);
    }
    public boolean move(CellPosition fromPosition, CellPosition toPosition) {
        return true;
    }
    public List<CellPosition> possibleMoves(CellPosition fromPosition) {
        return null;
    }
    public boolean validate(CellPosition fromPosition, CellPosition toPosition) {
        return true;
    }
}

Similarly implement Queen, Pawn, Bishop, Knight, Rook.

// PieceFactory.java
public class PieceFactory {
    public static Piece createPiece(PieceType type, Color color) {
        switch(type) {
            case PAWN:   return new Pawn(color);
            case ROOK:   return new Rook(color);
            case KNIGHT: return new Knight(color);
            case BISHOP: return new Bishop(color);
            case QUEEN:  return new Queen(color);
            case KING:   return new King(color);
            default: throw new IllegalArgumentException("Invalid piece type");
        }
    }
}

---

Game Management

// GameManager.java
import java.util.HashMap;
import java.util.Map;
public class GameManager {
    private static volatile GameManager instance;
    private Map<Integer, Chess> activeGames = new HashMap<>();
    private static int gameIdCounter = 1;

    private GameManager(){}

    public static GameManager getInstance() {
        if(instance == null) {
            synchronized (GameManager.class) {
                if(instance == null) {
                    instance = new GameManager();
                }
            }
        }
        return instance;
    }

    public synchronized int createGame(Player player1, Player player2) {
        Chess newGame = new Chess();
        newGame.player = new Player[]{player1, player2};
        newGame.currentPlayer = player1;  // White starts by default
        newGame.GameStatus = GameStatus.ACTIVE;
        newGame.ChessBoard = new ChessBoard();
        newGame.ChessBoard.resetBoard();

        int gameId = gameIdCounter++;
        activeGames.put(gameId, newGame);
        System.out.println("Game " + gameId + " created between " + player1.account.userName + " and " + player2.account.userName);
        return gameId;
    }

    public synchronized void endGame(int gameId, Player winner) {
        Chess game = activeGames.remove(gameId);
        if (game != null) {
            game.GameStatus = (winner != null) ? 
                (winner.color == Color.WHITE ? GameStatus.WHITE_WIN : GameStatus.BLACK_WIN) : GameStatus.FORTFEIGHT;
            System.out.println("Game " + gameId + " ended. Winner: " + (winner != null ? winner.account.userName : "Draw"));
        } else {
            System.out.println("Game " + gameId + " not found.");
        }
    }

    public synchronized Chess getGame(int gameId) {
        return activeGames.get(gameId);
    }
}

---

Tournament System

Tournament Strategy (Strategy Pattern)

// TournamentStrategy.java
import java.util.List;
public interface TournamentStrategy {
    void organizeMatches(List<Player> players, GameManager gameManager);
}

Example stub implementations (detailed match logic omitted):

// KnockoutTournament.java
import java.util.List;
public class KnockoutTournament implements TournamentStrategy {
    @Override
    public void organizeMatches(List<Player> players, GameManager gameManager) {
        System.out.println("Organizing matches using knockout tournament logic...");
        // Logic to organize knockout matches goes here.
    }
}

// RoundRobinTournament.java
import java.util.List;
public class RoundRobinTournament implements TournamentStrategy {
    @Override
    public void organizeMatches(List<Player> players, GameManager gameManager) {
        System.out.println("Organizing matches using round-robin tournament logic...");
        // Logic to organize round-robin matches goes here.
    }
}

Tournament Factory (Factory Pattern)

// TournamentFactory.java
import java.util.List;
public class TournamentFactory {
    public static Tournament createTournament(String type, String name, List<Player> players) {
        TournamentStrategy strategy;
        switch(type.toLowerCase()) {
            case "knockout":
                strategy = new KnockoutTournament();
                break;
            case "roundrobin":
                strategy = new RoundRobinTournament();
                break;
            default:
                throw new IllegalArgumentException("Invalid tournament type!");
        }
        return new Tournament(name, players, strategy);
    }
}

Observer Pattern: Tournament Notifications

// TournamentObserver.java
public interface TournamentObserver {
    void update(String message);
}

Tournament Class (Uses Strategy & Observer)

// Tournament.java
import java.util.ArrayList;
import java.util.List;
public class Tournament {
    private int tournamentId; 
    private String name;
    private List<Player> players;
    private TournamentStrategy strategy;
    private static int tournamentIdCounter = 1;
    private List<TournamentObserver> observers = new ArrayList<>();

    public Tournament(String name, List<Player> players, TournamentStrategy strategy) {
        this.tournamentId = tournamentIdCounter++;
        this.name = name;
        this.players = players;
        this.strategy = strategy;
    }

    public void addObserver(TournamentObserver observer) {
        observers.add(observer);
    }

    public void notifyObservers(String message) {
        for(TournamentObserver observer : observers) {
            observer.update(message);
        }
    }

    public void startTournament() {
        notifyObservers("Tournament '" + name + "' is starting!");
        strategy.organizeMatches(players, GameManager.getInstance());
        notifyObservers("Tournament '" + name + "' has ended!");
    }

    public int getTournamentId() {
        return tournamentId;
    }

    public String getName() {
        return name;
    }
}

Tournament Manager (Singleton)

// TournamentManager.java
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class TournamentManager {
    private static volatile TournamentManager instance;
    private Map<Integer, Tournament> tournaments = new HashMap<>();

    private TournamentManager() {}

    public static TournamentManager getInstance() {
        if (instance == null) {
            synchronized (TournamentManager.class) {
                if (instance == null) {
                    instance = new TournamentManager();
                }
            }
        }
        return instance;
    }

    public int createTournament(String type, String name, List<Player> players) {
        Tournament tournament = TournamentFactory.createTournament(type, name, players);
        // Add all players as observers for notifications
        for (Player player : players) {
            tournament.addObserver(player);
        }
        tournaments.put(tournament.getTournamentId(), tournament);
        return tournament.getTournamentId();
    }

    public void startTournament(int tournamentId) {
        Tournament tournament = tournaments.get(tournamentId);
        if (tournament != null) {
            tournament.startTournament();
        } else {
            System.out.println("Tournament ID not found.");
        }
    }
}

---

Main Class

// Main.java
import java.util.Arrays;
import java.util.List;
public class Main {
    public static void main(String[] args) {
        // --- Chess Game Demonstration ---
        GameManager gameManager = GameManager.getInstance();
        Player player1 = new Player(new Account("player1", "pass1", "John Doe", "[email protected]", "1234567890"), Color.WHITE);
        Player player2 = new Player(new Account("player2", "pass2", "Jane Smith", "[email protected]", "0987654321"), Color.BLACK);
        
        int gameId = gameManager.createGame(player1, player2);
        System.out.println("Game created with ID: " + gameId);
        
        // Demonstrate PieceFactory usage
        Piece whitePawn = PieceFactory.createPiece(PieceType.PAWN, Color.WHITE);
        Piece blackQueen = PieceFactory.createPiece(PieceType.QUEEN, Color.BLACK);
        System.out.println("Created a White Pawn: " + whitePawn.getClass().getSimpleName());
        System.out.println("Created a Black Queen: " + blackQueen.getClass().getSimpleName());
        
        // Simulate moving pieces (pseudo-move)
        CellPosition startPos = new CellPosition('e', 2);
        CellPosition endPos = new CellPosition('e', 4);
        if (whitePawn.move(startPos, endPos)) {
            System.out.println("White Pawn moved from " + startPos + " to " + endPos);
        } else {
            System.out.println("Invalid move for White Pawn.");
        }
        
        gameManager.endGame(gameId, player1);
        
        // --- Tournament Demonstration ---
        TournamentManager tournamentManager = TournamentManager.getInstance();
        Player player3 = new Player(new Account("player3", "pass3", "Alice", "[email protected]", "4567891230"), Color.WHITE);
        Player player4 = new Player(new Account("player4", "pass4", "Bob", "[email protected]", "7891234560"), Color.BLACK);
        
        List<Player> tournamentPlayers = Arrays.asList(player1, player2, player3, player4);
        // Create a tournament (switch type parameter to "roundrobin" if desired)
        int tournamentId = tournamentManager.createTournament("knockout", "Grand Chess Tournament", tournamentPlayers);
        tournamentManager.startTournament(tournamentId);
    }
}

---

5. Final Thoughts & Interview Tips

Key Discussion Points:

• Domain & Requirements: Explain the system’s responsibilities—from managing individual chess games to orchestrating tournaments.

• Design Patterns:

  • Factory Pattern: Use the TournamentFactory and PieceFactory to encapsulate object creation, adhering to the Open-Closed Principle.

  • Strategy Pattern: The TournamentStrategy interface lets you switch tournament rules without modifying the Tournament class.

  • Observer Pattern: Players implement TournamentObserver to receive notifications about tournament events, decoupling the notification mechanism.

  • Singleton Pattern: Ensures that both GameManager and TournamentManager are singletons for consistent global state.

• Scalability & Extensibility: Discuss how the design allows for adding new tournament types (e.g., Swiss system) or chess piece behaviors with minimal changes.

• Thread Safety: Mention using volatile and synchronized to prevent race conditions in multi-threaded environments.

How to Proceed in an Interview:

1. Outline the High-Level Design: Start by explaining the core components and how they interact.

2. Discuss Each Design Pattern: Explain why you used each pattern and the benefits it brings to the system.

3. Walk Through the Code: Highlight key sections (like Tournament, TournamentManager, and GameManager) to show the separation of concerns.

4. Answer Questions: Be prepared to discuss trade-offs, potential improvements (like persistence or real-time notifications), and thread-safety considerations.

By following this structured approach, you’ll demonstrate not only your coding skills but also your ability to design scalable, maintainable, and extensible systems.