Design a chess game - Low-Level Design Guide

Overview

Design a two-player chess game. Requirements: an 8x8 board with standard pieces; players alternate turns; each piece moves by its own rules; moves are validated (inside the board, path clear, cannot capture own piece, cannot leave your king in check); the game detects check, checkmate, and stalemate; moves are recorded for history and undo.

The design uses polymorphism for pieces (King, Queen, Rook, Bishop, Knight, Pawn each implement move rules), a Board that owns Squares and piece positions, a Move object (Command) recording from, to, piece, and captured piece for undo, and a Game that manages turns and status. Special rules (castling, en passant, promotion) are good extension discussions.

A referee with a rule book

Each piece knows how it may move, like players knowing their positions. The referee (game) checks turns, blocked paths, and whether a move would expose the king, and writes every move in the score sheet.

When to use it

LLD interview for polymorphism and game state.
Practicing Command for moves and undo.
Rules engines with validation layers.

Where it shows up in interviews

Board games

Recognize it when: turns, pieces, rules, win conditions.

Design chess
Design tic-tac-toe
Design snakes and ladders

Where it is used in real software

Chess engines

Stockfish uses bitboards and move generation for speed, but the conceptual model is the same.

Lichess and chess.com

Store games in PGN notation: a log of moves that can be replayed.

Game servers

Authoritative servers validate every move to prevent cheating.

Key terms

Piece: Abstract class with color and move rules.
Move: From, to, piece, captured piece; supports undo.
Pseudo-legal move: Follows piece rules but may leave the king in check.
Legal move: Pseudo-legal and does not leave own king in check.
Checkmate / stalemate: No legal moves while in check / not in check.

How it works, step by step

1
Clarify
Two local players? Special moves? Timers? Undo?
2
Entities
Game, Board, Piece hierarchy, Position, Move, Player, GameStatus.
3
Piece rules
Each piece returns whether a move is geometrically valid and needs a clear path.
4
Validation pipeline
Turn, bounds, own-piece capture, piece rule, path clear, king safety.
5
Status detection
After each move: check, checkmate, stalemate.

Validating Nf3 from g1

White's turn, knight on g1, target f3 empty

Check	Result
Is it white's turn and a white piece?	Yes
Target inside the board?	Yes
Knight L-shape (2,1)?	Yes: dr=2, dc=1
Path clear? (knights jump)	Not required
Own king left in check?	No: simulate move, test attacks

NOWCheck: Is it white's turn and a white piece? | Result: Yes

Move validation is a pipeline; piece-specific geometry is delegated polymorphically.

Implementation

1import java.util.*;2 3enum Color { WHITE, BLACK; Color other() { return this == WHITE ? BLACK : WHITE; } }4record Pos(int r, int c) { boolean inside() { return r >= 0 && r < 8 && c >= 0 && c < 8; } }5 6abstract class Piece {7    final Color color;8    Piece(Color color) { this.color = color; }9    /** Geometry only; board checks occupancy and path. */10    abstract boolean canMove(Pos from, Pos to, Board board);11    protected static boolean clearPath(Pos from, Pos to, Board b) {12        int dr = Integer.signum(to.r() - from.r()), dc = Integer.signum(to.c() - from.c());13        for (Pos p = new Pos(from.r() + dr, from.c() + dc); !p.equals(to); p = new Pos(p.r() + dr, p.c() + dc)) {14            if (b.at(p) != null) return false;15        }16        return true;17    }18}19 20final class Rook extends Piece {21    Rook(Color c) { super(c); }22    boolean canMove(Pos f, Pos t, Board b) { return (f.r() == t.r() || f.c() == t.c()) && clearPath(f, t, b); }23}24final class Bishop extends Piece {25    Bishop(Color c) { super(c); }26    boolean canMove(Pos f, Pos t, Board b) { return Math.abs(f.r() - t.r()) == Math.abs(f.c() - t.c()) && clearPath(f, t, b); }27}28final class Queen extends Piece {29    Queen(Color c) { super(c); }30    boolean canMove(Pos f, Pos t, Board b) { return new Rook(color).canMove(f, t, b) || new Bishop(color).canMove(f, t, b); }31}32final class Knight extends Piece {33    Knight(Color c) { super(c); }34    boolean canMove(Pos f, Pos t, Board b) { int dr = Math.abs(f.r() - t.r()), dc = Math.abs(f.c() - t.c()); return dr * dc == 2; }35}36final class King extends Piece {37    King(Color c) { super(c); }38    boolean canMove(Pos f, Pos t, Board b) { return Math.max(Math.abs(f.r() - t.r()), Math.abs(f.c() - t.c())) == 1; }39}40final class Pawn extends Piece {41    Pawn(Color c) { super(c); }42    boolean canMove(Pos f, Pos t, Board b) {43        int dir = color == Color.WHITE ? 1 : -1, start = color == Color.WHITE ? 1 : 6;44        int dr = t.r() - f.r(), dc = Math.abs(t.c() - f.c());45        Piece target = b.at(t);46        if (dc == 0 && target == null) return dr == dir || (f.r() == start && dr == 2 * dir && b.at(new Pos(f.r() + dir, f.c())) == null);47        return dc == 1 && dr == dir && target != null;          // diagonal capture48    }49}50 51record Move(Pos from, Pos to, Piece piece, Piece captured) {}52 53final class Board {54    private final Piece[][] grid = new Piece[8][8];55    Piece at(Pos p) { return grid[p.r()][p.c()]; }56    void put(Pos p, Piece piece) { grid[p.r()][p.c()] = piece; }57 58    Move apply(Pos from, Pos to) {59        Move m = new Move(from, to, at(from), at(to));60        put(to, m.piece()); put(from, null);61        return m;62    }63    void undo(Move m) { put(m.from(), m.piece()); put(m.to(), m.captured()); }64 65    Pos kingOf(Color c) {66        for (int r = 0; r < 8; r++) for (int col = 0; col < 8; col++) {67            Piece p = grid[r][col];68            if (p instanceof King && p.color == c) return new Pos(r, col);69        }70        throw new IllegalStateException("No king");71    }72 73    boolean attacked(Pos target, Color by) {74        for (int r = 0; r < 8; r++) for (int c = 0; c < 8; c++) {75            Piece p = grid[r][c];76            if (p != null && p.color == by && p.canMove(new Pos(r, c), target, this)) return true;77        }78        return false;79    }80 81    static Board standard() {82        Board b = new Board();83        for (Color color : Color.values()) {84            int back = color == Color.WHITE ? 0 : 7, pawns = color == Color.WHITE ? 1 : 6;85            Piece[] row = { new Rook(color), new Knight(color), new Bishop(color), new Queen(color), new King(color), new Bishop(color), new Knight(color), new Rook(color) };86            for (int c = 0; c < 8; c++) { b.put(new Pos(back, c), row[c]); b.put(new Pos(pawns, c), new Pawn(color)); }87        }88        return b;89    }90}91 92final class Game {93    enum Status { ACTIVE, CHECK, CHECKMATE, STALEMATE }94    private final Board board = Board.standard();95    private final Deque<Move> history = new ArrayDeque<>();96    private Color turn = Color.WHITE;97    private Status status = Status.ACTIVE;98 99    Status move(Pos from, Pos to) {100        if (status == Status.CHECKMATE || status == Status.STALEMATE) throw new IllegalStateException("Game over");101        if (!isLegal(from, to, turn)) throw new IllegalArgumentException("Illegal move");102        history.push(board.apply(from, to));103        turn = turn.other();104        status = evaluate(turn);105        return status;106    }107 108    void undo() { if (!history.isEmpty()) { board.undo(history.pop()); turn = turn.other(); status = evaluate(turn); } }109 110    private boolean isLegal(Pos from, Pos to, Color side) {111        if (!from.inside() || !to.inside() || from.equals(to)) return false;112        Piece p = board.at(from);113        if (p == null || p.color != side) return false;114        Piece target = board.at(to);115        if (target != null && target.color == side) return false;116        if (!p.canMove(from, to, board)) return false;117        Move m = board.apply(from, to);                           // simulate118        boolean kingSafe = !board.attacked(board.kingOf(side), side.other());119        board.undo(m);120        return kingSafe;121    }122 123    private Status evaluate(Color side) {124        boolean inCheck = board.attacked(board.kingOf(side), side.other());125        boolean anyLegal = false;126        outer:127        for (int r = 0; r < 8; r++) for (int c = 0; c < 8; c++) for (int r2 = 0; r2 < 8; r2++) for (int c2 = 0; c2 < 8; c2++) {128            if (isLegal(new Pos(r, c), new Pos(r2, c2), side)) { anyLegal = true; break outer; }129        }130        if (!anyLegal) return inCheck ? Status.CHECKMATE : Status.STALEMATE;131        return inCheck ? Status.CHECK : Status.ACTIVE;132    }133}

Complexity and performance

Move validationO(64) for king safety

Scan attackers.

Checkmate detection (naive)O(64^2 x 64)

Fine for a board this small.

Trade-offs

Clarity vs speed

Object-per-piece designs are clear; engines use bitboards for millions of positions per second.

Where rules live

Piece geometry in pieces, global rules (check, castling) in the game or a rule validator.

Variants and related techniques

Special moves

Castling, en passant, and promotion as special Move subclasses or flags.

Online play

Server validates moves, clocks per player, spectators via Observer.

Common mistakes

Board checking piece types with instanceof for movement.
Fix: Polymorphic canMove on each piece.
Forgetting that a move cannot leave your own king in check.
Fix: Simulate the move and test king safety.
No undo capability.
Fix: Record Move objects with captured pieces.

Interview questions

How do you validate a chess move?

Check turn and ownership, bounds, not capturing your own piece, the piece's movement rule (polymorphic canMove), path clearance for sliding pieces, then simulate the move and ensure your own king is not attacked.

How would you detect checkmate?

After a move, check whether the opponent's king is attacked and whether the opponent has any legal move. In check with no legal moves is checkmate; not in check with no legal moves is stalemate.

Practice problems

Problem	Difficulty	What it trains
Tic-tac-toe with win detection	Easy	Game loop.
Chess with check and checkmate	Hard	Validation pipeline.