Design an Extensible Animal-Chess Game Engine

Design an Extensible Animal-Chess Engine

Design the core engine for a turn-based board game (e.g., Dou Shou Qi). The engine must be extensible, allowing for future variations in board size, animal types, and specific movement or capture rules without modifying existing engine logic.

Requirements

1. Immutability: Game state should be immutable. Every move should produce a new state rather than modifying the existing one.
2. Rule Separation: The logic for checking if a move is valid (e.g., "Can an Elephant capture a Mouse?") must be separated from the board state representation.
3. Persistence/Replay: The design must support saving the history of moves to reconstruct any previous state deterministically.
4. Concurrency: Multiple users might be viewing or querying the state simultaneously; ensure the design is thread-safe.

Task

Provide a high-level class structure or pseudo-code showing how the following components interact:

• GameState: Represents the board and pieces.
• MoveValidator: A strategy-based interface to validate moves.
• GameEngine: Orchestrates turns, state transitions, and history.

Example Interface

class Move:
    def __init__(self, piece_id, from_coords, to_coords):
        pass

class GameState:
    # Represents board at a specific point in time
    pass

class GameEngine:
    def apply_move(self, move: Move) -> GameState:
        # 1. Validate move
        # 2. Return new state if valid, else raise exception
        pass

Consider how you would structure the MoveValidator so that adding a new rule (e.g., "a piece cannot move into water") doesn't require editing the GameEngine.