基于OOPS的国际象棋游戏：棋子移动后逻辑处理及模式选型咨询

Awesome question—building a chess game with OOP is a classic problem that forces you to think hard about single responsibility and clean separation of concerns, especially when handling all those post-move edge cases. Let’s break this down step by step.

Before diving into the post-move logic, let’s set up a solid base of classes with clear roles:

• ChessBoard: The single source of truth for all piece positions, legal move validation, and state checks (like if a king is in check). It knows the layout of the board and can query any piece’s location.
• Piece (abstract base class): All specific pieces inherit from this. It holds basic properties like color and currentPosition, plus an abstract method getValidMoves(ChessBoard board) that each piece implements to define its unique movement rules. You can also add an optional onMoveCompleted(Game game) hook for piece-specific post-move behavior.
• Concrete Piece Classes: Pawn, King, Queen, Rook, Bishop, Knight—each implements getValidMoves() and any piece-specific logic (like pawn en passant rules, another post-move edge case!).
• Game: Manages the overall flow—player turns, accepting move inputs, coordinating between ChessBoard and pieces, and handling user interactions (like prompting for pawn promotion choices).

Let’s map each of your cases to the right classes and logic:

1. Pawn Promotion #

• Trigger: A pawn moves to the opponent’s back rank (white pawn to row 8, black pawn to row 1).
• Responsibility Split:
  • The Pawn class should have a helper method like requiresPromotion() that checks if its current position is on the promotion rank. Alternatively, ChessBoard can validate this after a move is executed.
  • The Game class takes over next: it prompts the player to choose a replacement piece (queen, rook, bishop, knight), then tells ChessBoard to remove the pawn and place the selected piece in its position.
• Example Flow: After ChessBoard confirms a valid pawn move, Game calls pawn.requiresPromotion(). If true, show a selection menu, then execute board.replacePiece(pawn, newQueen) (or whatever the player picks).

2. Check (King Under Attack) #

• Trigger: After a move, the opponent’s king is within the attack range of any of the current player’s pieces.
• Responsibility: This lives entirely in ChessBoard. Since it needs visibility to all pieces on the board, it can implement a method like isKingInCheck(Color targetColor):
  1. Find the position of the target color’s king.
  2. Iterate over all enemy pieces, check if any of their valid moves include the king’s position.
• Usage: Game calls this method immediately after every valid move. If it returns true, it marks the game state as "in check" and ensures the next player’s move must resolve this.

3. Checkmate (Game Over) #

• Trigger: The opponent is in check, and has no valid moves that will get their king out of check.
• Responsibility: A combination of ChessBoard and Game:
  1. First, ChessBoard confirms the king is in check (using isKingInCheck()).
  2. Then Game checks all possible valid moves for the player in check: for every piece they own, generate all valid moves, simulate each move on a temporary board copy, and check if the king is still in check after that simulated move.
  3. If none of the simulated moves resolve the check, Game declares checkmate and ends the game.

Absolutely—this pattern is perfect for post-move processing because it lets you decouple each edge case into its own handler, and execute them in a specific order without tightly coupling them to the core game logic.

Here’s how you’d implement it:

1. Create an abstract MovePostProcessor class with a process(GameState state) method, plus a setNextProcessor(MovePostProcessor next) method to chain handlers.
2. Make concrete processors for each scenario:
   • PromotionProcessor: Checks if a pawn needs promotion, handles the replacement logic, then passes the state to the next processor.
   • CheckProcessor: Runs the isKingInCheck() check and updates the game state.
   • CheckmateProcessor: Verifies if the current check state leads to checkmate.
   • You could even add others like StalemateProcessor or EnPassantProcessor later.
3. In your Game class, set up the chain in the correct order (promotion first, since it changes the board state before check checks), then pass the post-move game state through the chain after every valid move.

Why This Works #

• Open/Closed Principle: You can add new post-move handlers (like threefold repetition for draws) without modifying existing code.
• Single Responsibility: Each processor only cares about one specific edge case—no messy if/else blocks cluttering your Game or ChessBoard classes.
• Flexibility: You can reorder the chain if needed, or skip certain processors for specific game modes (like a "no promotion" variant).

Start with clear, single-responsibility classes to keep your core logic clean. For post-move scenarios, using the Chain of Responsibility pattern will make your code far more maintainable and extensible as you add more chess rules. Don’t forget to test each handler independently—this makes debugging edge cases way easier!

内容的提问来源于stack exchange，提问作者Nishat