Board and piece hierarchy in LLD - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the purpose of a 'Board' class in a board game design?

The 'Board' class represents the playing area where pieces are placed and moved. It manages the layout, tracks piece positions, and enforces rules related to the board's state.

beginner

Why use a base 'Piece' class in a board game hierarchy?

A base 'Piece' class provides common properties and behaviors for all game pieces, such as position and movement rules. It allows easy extension for specific piece types while keeping code organized.

intermediate

How does inheritance help in designing different game pieces?

Inheritance lets specific pieces inherit common features from a base class and add unique behaviors. For example, a 'Knight' piece can inherit from 'Piece' and implement its special move logic.

intermediate

What role does encapsulation play in board and piece design?

Encapsulation hides the internal details of board and piece classes, exposing only necessary methods. This protects the game state from unintended changes and simplifies maintenance.

advanced

How can composition be used alongside inheritance in board game design?

Composition allows a piece to have components like movement strategies or attack behaviors as separate objects. This adds flexibility beyond inheritance by mixing behaviors dynamically.

What does the 'Board' class typically manage in a board game?

A The layout and positions of pieces

B The player scores

C The user interface colors

D The network connections

The Board class manages the layout and tracks where pieces are placed on the board.

Which OOP concept allows different pieces to share common features?

A Inheritance

B Encapsulation

C Abstraction

D Polymorphism

Inheritance lets different pieces share common properties and methods from a base class.

Why is encapsulation important in piece design?

A To make the UI colorful

B To hide internal details and protect game state

C To allow direct access to piece data

D To speed up the game

Encapsulation hides internal details, preventing unintended changes to the game state.

What is a benefit of using composition in piece behavior?

A Forcing all pieces to behave the same

B Reducing code readability

C Mixing behaviors dynamically

D Making the board smaller

Composition allows combining different behaviors dynamically for flexibility.

Which class would most likely contain the rules for piece movement?

A GameController

B Board

C Player

D Piece

The Piece class or its subclasses define how each piece moves.

Explain how you would design a board and piece hierarchy for a simple chess game.

Think about what each class should know and do.

Describe the advantages of combining inheritance and composition in game piece design.

Consider how pieces can share and differ in behavior.

Practice

1. What is the main purpose of having a base Piece class in a board game design?

easy

A. To manage network communication between players

B. To define common properties like position and type for all pieces

C. To handle user input events

D. To store the entire board layout

Solution

1. Step 1: Understand the role of a base class

   A base class provides shared properties and methods for all derived classes, avoiding repetition.

2. Step 2: Apply to board game pieces

   All pieces share common traits like position and type, so the base Piece class holds these.

3. Final Answer:

   To define common properties like position and type for all pieces -> Option B

4. Quick Check:

   Base class = common properties [OK]

Hint: Base class holds shared traits for all pieces [OK]

Common Mistakes:

• Confusing board layout storage with piece properties
• Thinking base class handles user input
• Assuming base class manages network tasks

2. Which of the following is the correct way to declare a subclass King that extends a base Piece class in a typical object-oriented design?

easy

A. class King extends Piece { constructor(position) { super(position); } }

B. function King() { this.position = position; } extends Piece

C. class King inherits Piece { constructor() { } }

D. King = Piece + position

Solution

1. Step 1: Identify correct subclass syntax

   In modern OOP, a subclass uses extends keyword and calls super() in constructor.

2. Step 2: Check each option

   class King extends Piece { constructor(position) { super(position); } } uses correct syntax: class King extends Piece { constructor(position) { super(position); } }.

3. Final Answer:

   class King extends Piece { constructor(position) { super(position); } } -> Option A

4. Quick Check:

   Subclass syntax = extends + super() [OK]

Hint: Subclass uses extends and calls super() in constructor [OK]

Common Mistakes:

• Using incorrect keywords like inherits
• Placing extends after function declaration
• Trying to add properties with '+' operator

3. Given this code snippet for a board and pieces, what will be the output of console.log(board.pieces[0].type);?

class Piece {
  constructor(type, position) {
    this.type = type;
    this.position = position;
  }
}
class Board {
  constructor() {
    this.pieces = [];
  }
  addPiece(piece) {
    this.pieces.push(piece);
  }
}
const board = new Board();
board.addPiece(new Piece('Knight', 'B1'));

medium

A. undefined

B. "B1"

C. Error: pieces is not defined

D. "Knight"

Solution

1. Step 1: Understand object creation and storage

   A new Piece with type 'Knight' and position 'B1' is created and added to board.pieces.

2. Step 2: Access the first piece's type

   board.pieces[0] refers to the first piece, so board.pieces[0].type is 'Knight'.

3. Final Answer:

   "Knight" -> Option D

4. Quick Check:

   First piece type = 'Knight' [OK]

Hint: First piece type is stored in pieces[0].type [OK]

Common Mistakes:

• Confusing position with type
• Assuming pieces array is empty
• Expecting an error due to missing pieces

4. Identify the error in this piece hierarchy code snippet:

class Piece {
  constructor(type, position) {
    this.type = type;
    this.position = position;
  }
}
class Queen extends Piece {
  constructor(position) {
    this.type = 'Queen';
    this.position = position;
  }
}

medium

A. Position should not be passed to constructor

B. Queen class should not have a constructor

C. Missing call to super() in Queen constructor

D. Type should be passed as parameter to Queen constructor

Solution

1. Step 1: Review subclass constructor rules

   In subclasses, the constructor must call super() before using this.

2. Step 2: Check Queen constructor

   Queen constructor assigns this.type and this.position without calling super(), causing an error.

3. Final Answer:

   Missing call to super() in Queen constructor -> Option C

4. Quick Check:

   Subclass constructor must call super() first [OK]

Hint: Always call super() before using this in subclass constructor [OK]

Common Mistakes:

• Forgetting super() call in subclass constructor
• Trying to assign this before super()
• Assuming constructor is optional in subclass

5. You want to design a scalable board game system where each piece type has unique movement rules. Which design approach best supports adding new piece types without changing existing code?

hard

A. Use a base Piece class and create subclasses for each piece type implementing their own move logic

B. Store all piece types and moves in a single large switch-case statement

C. Keep piece types as strings and handle moves in a separate global function with if-else

D. Use a flat list of pieces with no hierarchy and hardcode moves in the board class

Solution

1. Step 1: Understand scalability and extensibility

   Good design allows adding new piece types without modifying existing code, following open-closed principle.

2. Step 2: Evaluate design options

   Subclassing Piece lets each piece implement its own move logic, enabling easy extension.

3. Final Answer:

   Use a base Piece class and create subclasses for each piece type implementing their own move logic -> Option A

4. Quick Check:

   Subclassing = scalable and extensible design [OK]

Hint: Subclass each piece type for unique moves [OK]

Common Mistakes:

• Using large switch-case blocks that are hard to maintain
• Handling moves globally with if-else reduces flexibility
• Hardcoding moves in board class limits scalability