Piece movement rules (polymorphism) in LLD - Architecture Diagram

System Overview - Piece movement rules (polymorphism)

This system models the movement rules of different game pieces using polymorphism. Each piece type (like pawn, rook, knight) has its own movement logic encapsulated in separate classes. The system allows easy extension and clear separation of movement behaviors.

Architecture Diagram

User
  |
  v
Game Controller
  |
  v
Piece (abstract class/interface)
  |         |          |          |
Pawn     Rook      Knight     Bishop
  |         |          |          |
Movement Logic (overridden methods)
  |
Board
  |
Move Validator
  |
Game State

Components

User

actor

Interacts with the game by making move requests

Game Controller

service

Receives user input and coordinates piece movement validation

Piece (abstract class/interface)

component

Defines the common interface for all piece movement rules

Pawn

component

Implements pawn-specific movement logic

Rook

component

Implements rook-specific movement logic

Knight

component

Implements knight-specific movement logic

Bishop

component

Implements bishop-specific movement logic

Board

component

Represents the game board and current piece positions

Move Validator

service

Checks if a move is valid according to piece rules and board state

Game State

component

Maintains the current state of the game including turn and piece positions

Request Flow - 8 Hops

User → Game Controller

Game Controller → Piece (abstract class/interface)

Piece (abstract class/interface) → Specific Piece Implementation (e.g., Pawn, Rook, Knight, Bishop)

Specific Piece Implementation → Move Validator

Move Validator → Board

Move Validator → Game Controller

Game Controller → Game State

Game Controller → User

Failure Scenario

Component Fails:Move Validator

Impact:Invalid moves may be accepted or valid moves rejected, breaking game rules

Mitigation:Implement thorough unit tests for move validation logic and fallback to default deny on error

Architecture Quiz - 3 Questions

Which component is responsible for defining the common interface for all piece movement rules?

A Piece (abstract class/interface)

B Game Controller

C Move Validator

D Board

Design Principle

This design uses polymorphism to encapsulate different piece movement rules in separate classes, promoting code reuse and easy extension. The system cleanly separates concerns: user input handling, movement logic, validation, and game state management, which improves maintainability and scalability.

Practice

1. What is the main benefit of using polymorphism for piece movement rules in a game design?

easy

A. It allows each piece to have its own move logic without type checks.

B. It forces all pieces to share the same move logic.

C. It requires manual checking of piece types before moving.

D. It prevents pieces from moving on the board.

Solution

1. Step 1: Understand polymorphism concept

   Polymorphism allows different objects to be treated through a common interface while having their own behavior.

2. Step 2: Apply to piece movement

   Each piece class implements its own move() method, so no need to check piece type before moving.

3. Final Answer:

   It allows each piece to have its own move logic without type checks. -> Option A

4. Quick Check:

   Polymorphism = own move logic without type checks [OK]

Hint: Polymorphism means no type checks for moves [OK]

Common Mistakes:

• Thinking all pieces share the same move logic
• Believing manual type checks are needed
• Confusing polymorphism with inheritance only

2. Which of the following is the correct way to declare a base class method for piece movement in a polymorphic design?

easy

A. move(self): pass

B. def move(self): pass

C. def move(): pass

D. def move(self, board): return

Solution

1. Step 1: Recall method declaration syntax in Python

   Instance methods must have self as the first parameter.

2. Step 2: Identify correct method signature

   def move(self): pass correctly declares a method with self and no implementation.

3. Final Answer:

   def move(self): pass -> Option B

4. Quick Check:

   Method with self parameter = def move(self): pass [OK]

Hint: Instance methods always start with self parameter [OK]

Common Mistakes:

• Omitting self parameter in method
• Using incorrect syntax without def keyword
• Adding unnecessary parameters without context

3. Given the following code, what will be the output?

class Piece:
    def move(self):
        return "Base move"

class Knight(Piece):
    def move(self):
        return "L-shaped move"

pieces = [Piece(), Knight()]
for p in pieces:
    print(p.move())

medium

A. Base move\nL-shaped move

B. L-shaped move\nL-shaped move

C. Error: move() not implemented

D. Base move\nBase move

Solution

1. Step 1: Understand method overriding

   Subclass Knight overrides move() to return "L-shaped move".

2. Step 2: Trace the loop output

   First object is Piece, prints "Base move"; second is Knight, prints "L-shaped move".

3. Final Answer:

   Base move\nL-shaped move -> Option A

4. Quick Check:

   Base class and overridden subclass moves printed [OK]

Hint: Subclass method overrides base method output [OK]

Common Mistakes:

• Assuming base method always runs
• Expecting same output for all pieces
• Confusing method overriding with overloading

4. Identify the error in the following polymorphic piece movement code:

class Piece:
    def move(self):
        pass

class Bishop(Piece):
    def move():
        print("Diagonal move")

b = Bishop()
b.move()

medium

A. Cannot instantiate Bishop directly

B. Piece.move() should return a value

C. Bishop.move() missing self parameter

D. print statement syntax error

Solution

1. Step 1: Check method signatures

   Bishop.move() lacks self parameter, so it is not a proper instance method.

2. Step 2: Understand call context

   Calling b.move() passes self automatically, causing a TypeError due to missing parameter.

3. Final Answer:

   Bishop.move() missing self parameter -> Option C

4. Quick Check:

   Instance methods must have self parameter [OK]

Hint: Instance methods always need self parameter [OK]

Common Mistakes:

• Ignoring missing self in subclass method
• Thinking base class method must return value
• Assuming print syntax is wrong

5. You are designing a chess game using polymorphism for piece movement. How should you structure your classes to allow easy addition of new piece types without changing existing code?

hard

A. Write a single move() function with if-else for each piece type.

B. Implement move logic only in the base class and override rarely.

C. Use global variables to track piece types and moves.

D. Create a base Piece class with an abstract move() method; each piece subclass implements move().

Solution

1. Step 1: Apply polymorphism design principle

   Use a base class with an abstract or empty move() method to define interface.

2. Step 2: Implement subclasses for each piece

   Each piece subclass provides its own move() logic, enabling extension without modifying base code.

3. Final Answer:

   Create a base Piece class with an abstract move() method; each piece subclass implements move(). -> Option D

4. Quick Check:

   Base class + subclass move() = scalable design [OK]

Hint: Base class with abstract move() enables easy extension [OK]

Common Mistakes:

• Using if-else instead of polymorphism
• Relying on global variables for logic
• Putting all move logic in base class only