Let's revisit the classic chess game, but with a focus on building a robust, extensible, and thread-safe implementation. We're not aiming for an AI opponent or a fancy GUI here. Instead, the focus is on the core logic: representing the board, handling piece movements, enforcing rules, and managing game state. This problem is designed to test your low-level design skills, your ability to apply object-oriented principles, and your understanding of concurrency.

A key element to consider is how to represent valid moves. A naive approach might involve checking every possible square on the board, which quickly becomes inefficient. We need to consider how to effectively pre-calculate and store possible moves for a given piece, taking into account blocking pieces and the specific movement rules of each chess piece.

Furthermore, think about how different game modes (e.g., standard chess, chess variants) could be supported without major code rewrites. How can we inject new rules or pieces into the game while maintaining a clean and maintainable design?

The challenge lies in crafting a design that is both elegant and practical, balancing the need for performance with the desire for a flexible and extensible architecture. This means carefully considering the use of design patterns to manage complexity and promote code reuse.

Requirements