Why chess tests polymorphism and strategy in LLD - Why This Architecture

Problem Statement

Without a flexible design, adding new chess pieces or changing their behavior requires rewriting large parts of the code, making it hard to maintain and extend. This rigidity leads to bugs and slows down development when implementing new strategies or rules.

Solution

Chess uses polymorphism to let each piece define its own movement rules while sharing a common interface. Strategy pattern allows the game to change or select different move strategies dynamically, enabling flexible and maintainable code that can easily adapt to new rules or AI behaviors.

Architecture

ChessGame

→Piece (base)

↓

Pawn

↓

MoveStrategy

◀──────────────┐

↓

Aggressive

This diagram shows ChessGame using a base Piece class with polymorphic subclasses for each piece type. MoveStrategy interface allows dynamic selection of different move behaviors like Aggressive or Defensive.

Trade-offs

✓ Pros

→

Enables adding new piece types without changing existing code.

→

Supports dynamic change of move strategies at runtime.

→

Improves code maintainability and readability by separating concerns.

→

Facilitates testing different AI strategies independently.

✗ Cons

→

Introduces more classes and interfaces, increasing initial complexity.

→

May add slight runtime overhead due to dynamic dispatch.

→

Requires careful design to avoid excessive subclassing or strategy proliferation.

Use when the system needs to support multiple piece types with different behaviors and when move strategies may change or extend over time, especially in AI or rule variations.

Avoid if the chess implementation is very simple, fixed, and unlikely to change, as the added abstraction may be unnecessary overhead.

Real World Examples

Chess.com

Uses polymorphism to represent different chess pieces and strategy pattern to implement various AI difficulty levels and move strategies.

Lichess

Applies polymorphism for piece behavior and strategy pattern to allow different AI engines and custom rule sets.

DeepMind (AlphaZero)

Implements flexible strategy selection to train and test different move policies dynamically.

Code Example

Before, the ChessGame class had separate methods for each piece, making it hard to add new pieces or change behavior. After applying polymorphism, each piece class implements its own move method. The Strategy pattern allows selecting different move behaviors dynamically, improving flexibility and maintainability.

LLD

### Before: No polymorphism or strategy
class ChessGame:
    def move_pawn(self, position):
        # specific pawn move logic
        pass
    def move_knight(self, position):
        # specific knight move logic
        pass

### After: Using polymorphism and strategy
from abc import ABC, abstractmethod

class Piece(ABC):
    @abstractmethod
    def move(self, position):
        pass

class Pawn(Piece):
    def move(self, position):
        # pawn-specific move logic
        print(f"Pawn moves to {position}")

class Knight(Piece):
    def move(self, position):
        # knight-specific move logic
        print(f"Knight moves to {position}")

class MoveStrategy(ABC):
    @abstractmethod
    def select_move(self, piece, position):
        pass

class AggressiveStrategy(MoveStrategy):
    def select_move(self, piece, position):
        print("Aggressive move selected")
        piece.move(position)

class DefensiveStrategy(MoveStrategy):
    def select_move(self, piece, position):
        print("Defensive move selected")
        piece.move(position)

# Usage
pawn = Pawn()
knight = Knight()
strategy = AggressiveStrategy()
strategy.select_move(pawn, "E4")
strategy = DefensiveStrategy()
strategy.select_move(knight, "F6")

Alternatives

Procedural design

Uses conditional statements to handle piece behavior instead of polymorphism and strategy objects.

Use when: Choose when the system is very small and unlikely to change, and simplicity is preferred over flexibility.

State pattern

Encapsulates piece states and transitions rather than move strategies.

Use when: Choose when piece behavior depends heavily on internal states like promotion or en passant.

Summary

Polymorphism allows each chess piece to define its own movement behavior through a shared interface.

Strategy pattern enables dynamic selection of move behaviors, supporting flexible AI and rule variations.

Together, they make the chess system easier to extend, maintain, and test.