Win condition checking in LLD - System Design Guide

Problem Statement

Without a clear and efficient way to check if a player has won, games can become slow or incorrect, causing poor user experience and frustration. Naive win checking can lead to redundant computations and delayed game responses.

Solution

Implement a systematic approach that checks the game state after each move to determine if a win condition is met. This involves tracking relevant game elements and applying concise logic to verify if a player has achieved the winning criteria immediately after their action.

Architecture

Player makes

a move

↓

Update game

state

↓

Check win

condition

↓

Win

found

This diagram shows the flow from a player's move to updating the game state, then checking the win condition, and finally deciding if the game ends or continues.

Trade-offs

✓ Pros

→

Ensures immediate feedback to players about game outcomes.

→

Reduces unnecessary checks by focusing only on relevant parts of the game state.

→

Improves game responsiveness and user experience.

✗ Cons

→

Requires careful design to cover all possible win scenarios.

→

Can become complex for games with multiple or dynamic win conditions.

→

May add overhead if not optimized, especially in large or complex games.

Use when building turn-based or real-time games where immediate and accurate win detection is critical, especially for games with defined and limited win conditions.

Avoid in games where win conditions are probabilistic or evaluated only at the end, or when the game state is too large to check efficiently after each move.

Real World Examples

Nintendo

In games like Chess or Tic-Tac-Toe, Nintendo implements efficient win condition checks after each move to instantly declare a winner or continue play.

Blizzard Entertainment

In Hearthstone, win conditions are checked after each card play or attack to determine if a player’s health reaches zero, ending the game immediately.

Epic Games

In Fortnite, the system checks if a player is the last one standing after each elimination to declare the winner.

Code Example

The before code checks all rows, columns, and diagonals after every move, which is repetitive and inefficient. The after code keeps counters for rows, columns, and diagonals updated with each move, allowing instant win detection by checking only these counters.

LLD

### Before: Naive win checking after every move by scanning entire board
class Game:
    def __init__(self):
        self.board = [[None]*3 for _ in range(3)]

    def make_move(self, x, y, player):
        self.board[x][y] = player
        if self.check_win():
            print(f"Player {player} wins!")

    def check_win(self):
        # Check all rows, columns, diagonals
        for i in range(3):
            if self.board[i][0] == self.board[i][1] == self.board[i][2] != None:
                return True
            if self.board[0][i] == self.board[1][i] == self.board[2][i] != None:
                return True
        if self.board[0][0] == self.board[1][1] == self.board[2][2] != None:
            return True
        if self.board[0][2] == self.board[1][1] == self.board[2][0] != None:
            return True
        return False

### After: Optimized win checking by tracking last move
class Game:
    def __init__(self):
        self.board = [[None]*3 for _ in range(3)]
        self.rows = [0]*3
        self.cols = [0]*3
        self.diag = 0
        self.anti_diag = 0

    def make_move(self, x, y, player):
        val = 1 if player == 'X' else -1
        self.board[x][y] = player
        self.rows[x] += val
        self.cols[y] += val
        if x == y:
            self.diag += val
        if x + y == 2:
            self.anti_diag += val
        if abs(self.rows[x]) == 3 or abs(self.cols[y]) == 3 or abs(self.diag) == 3 or abs(self.anti_diag) == 3:
            print(f"Player {player} wins!")

Alternatives

End-of-game evaluation

Checks win conditions only after the game ends rather than after each move.

Use when: Use when game outcomes depend on cumulative scoring or complex end states rather than immediate moves.

Event-driven win checking

Triggers win checks only on specific events rather than every move.

Use when: Use when only certain actions can lead to a win, reducing unnecessary checks.

Summary

Win condition checking prevents slow or incorrect game outcomes by verifying wins immediately after moves.

Efficient implementations track relevant game state changes to avoid scanning the entire board repeatedly.

This pattern improves game responsiveness and user experience by providing instant feedback on game status.

Practice

1. What is the primary purpose of win condition checking in a game system?

easy

A. To update the player's score after each move

B. To determine if a player has won the game by matching symbols in a row, column, or diagonal

C. To reset the game board after a draw

D. To display the game instructions to the player

Solution

1. Step 1: Understand the role of win condition checking

   Win condition checking is used to decide if the game has ended with a winner by checking patterns on the board.

2. Step 2: Identify the correct purpose among options

   Only To determine if a player has won the game by matching symbols in a row, column, or diagonal describes checking rows, columns, or diagonals for matching symbols to declare a winner.

3. Final Answer:

   To determine if a player has won the game by matching symbols in a row, column, or diagonal -> Option B

4. Quick Check:

   Win condition checking = Determine winner [OK]

Hint: Win condition means checking if someone won the game [OK]

Common Mistakes:

• Confusing win checking with score updating
• Thinking it resets the game board
• Assuming it shows instructions

2. Which of the following code snippets correctly checks a row for a win in a 3x3 tic-tac-toe board represented as a 2D array board?

easy

A. if board[row][0] != board[row][1] != board[row][2]:

B. if board[0][row] == board[1][row] == board[2][row] != None:

C. if board[row][0] == board[row][1] == board[row][2] != None:

D. if board[0][0] == board[1][1] == board[2][2] != None:

Solution

1. Step 1: Identify row checking syntax

   Checking a row means comparing all elements in the same row index but different columns.

2. Step 2: Match code to row check

   if board[row][0] == board[row][1] == board[row][2] != None: compares board[row][0], board[row][1], and board[row][2], which is correct for a row check.

3. Final Answer:

   if board[row][0] == board[row][1] == board[row][2] != None: -> Option C

4. Quick Check:

   Row check = compare same row elements [OK]

Hint: Row check compares same row, different columns [OK]

Common Mistakes:

• Mixing row and column indices
• Using != instead of == for equality
• Checking diagonal instead of row

3. Given the following 3x3 board state:

board = [["X", "O", "X"],
         ["O", "X", "O"],
         ["O", "X", "X"]]

Which of these checks will correctly identify a win for 'X' on the main diagonal?

medium

A. board[0][0] == board[1][1] == board[2][2] == "X"

B. board[0][2] == board[1][1] == board[2][0] == "X"

C. board[0][0] == board[0][1] == board[0][2] == "X"

D. board[2][0] == board[2][1] == board[2][2] == "X"

Solution

1. Step 1: Identify main diagonal positions

   Main diagonal cells are at positions (0,0), (1,1), and (2,2).

2. Step 2: Check which option matches main diagonal and 'X'

   board[0][0] == board[1][1] == board[2][2] == "X" compares these exact positions to 'X', correctly checking the main diagonal win.

3. Final Answer:

   board[0][0] == board[1][1] == board[2][2] == "X" -> Option A

4. Quick Check:

   Main diagonal check = positions (0,0),(1,1),(2,2) [OK]

Hint: Main diagonal is top-left to bottom-right [OK]

Common Mistakes:

• Confusing main diagonal with anti-diagonal
• Checking wrong row or column
• Using equality with wrong symbol

4. Consider this code snippet for checking a column win:

def check_column(board, col):
    return board[0][col] == board[1][col] == board[2][col]

What is the main issue with this code when used for win condition checking?

medium

A. It only checks rows, not columns

B. It uses incorrect indices for columns

C. It returns a list instead of a boolean

D. It does not check if the cells are not empty or None

Solution

1. Step 1: Analyze the equality check

   The code checks if all three cells in the column are equal but does not verify if they are non-empty.

2. Step 2: Identify missing condition for valid win

   Without checking for None or empty, it may falsely report a win if all cells are empty.

3. Final Answer:

   It does not check if the cells are not empty or None -> Option D

4. Quick Check:

   Check for non-empty cells to confirm win [OK]

Hint: Always check cells are not empty before confirming win [OK]

Common Mistakes:

• Ignoring empty or None cells in equality
• Mixing row and column indices
• Expecting a list return instead of boolean

5. You are designing a scalable win condition checker for an n x n board game. Which approach best balances efficiency and scalability?

hard

A. Only check the row, column, and diagonals related to the last move

B. Check all rows, columns, and both diagonals after every move

C. Check the entire board for a winner after every move

D. Check only the diagonals after every move

Solution

1. Step 1: Understand the cost of checking all lines

   Checking all rows, columns, and diagonals after every move is expensive for large boards.

2. Step 2: Focus on last move's related lines

   Only the row, column, and diagonals that include the last move can change the win state, so checking these is efficient and scalable.

3. Final Answer:

   Only check the row, column, and diagonals related to the last move -> Option A

4. Quick Check:

   Check only affected lines after move for efficiency [OK]

Hint: Check only lines affected by last move for best performance [OK]

Common Mistakes:

• Checking entire board every time wastes resources
• Ignoring diagonals in win checking
• Checking unrelated rows or columns