Optimize ChessExplorer for depth 7 - Strategy #2 - ChessPiece calculates its own moves.

Here's a GitHub Issue Ticket for the refactoring task you described:

Refactor ChessPiece Move Validation

Description:

The current implementation of the IsCheckMate method in our chess engine uses a brute force approach to validate moves for all chess pieces. This leads to unnecessary performance overhead, especially when dealing with pieces like pawns that have limited mobility. The goal of this refactoring is to:

Improve Efficiency: Reduce the number of iterations by having each ChessPiece calculate its own valid moves based on the current board state.
Enhance Debuggability: Simplify the logic to make debugging easier, by removing the nested loops over all board squares.
Performance: Optimize performance, particularly for the ChessStateExplorer which struggles with depth due to the current inefficient move validation.

Current Implementation:

// ... (existing code snippet) ...

Proposed Changes:

Introduce GetValidSquares(ChessBoard chessBoard) Method:
- Add this method to the ChessPiece abstract class. Each specific piece type (like ChessPiecePawn, ChessPieceKnight, etc.) will implement this method to return a List<Square> of valid squares it can move to based on the current state of the chessboard.

Refactor IsCheckMate Method:

Replace the brute force loop with a call to GetValidSquares for each piece. Instead of iterating over all 64 squares for each piece, we'll only check the squares returned by GetValidSquares.

Example Refactored Code:

public bool IsCheckMate(Turn turn, out bool isStaleMate)
{
   StaticLogger.Trace();
   List<ChessPiece> friendlyPieces = turn.PlayerTurn.Equals(Turn.Color.WHITE)
       ? turn.ChessPieces.FindAll(piece => piece.GetColor().Equals(ChessPiece.Color.BLACK))
       : turn.ChessPieces.FindAll(piece => piece.GetColor().Equals(ChessPiece.Color.WHITE));

   List<Turn> possibleMoves = new();

   foreach (ChessPiece piece in friendlyPieces)
   {
       SpecialMovesHandlers.ByPassPawnPromotionPromptUser = true;
       SimulationService.BeginSimulation();
       foreach (Square sq in piece.GetValidSquares(turn.ChessBoard))
       {
           Turn possibleTurn = new(turn.TurnNumber + 1, piece, piece.GetCurrentPosition(), sq.Position, turn.ChessBoard);
           if (possibleTurn.IsValidTurn)
               possibleMoves.Add(possibleTurn);
       }
       SpecialMovesHandlers.ByPassPawnPromotionPromptUser = false;
       SimulationService.EndSimulation();
   }

   // ... (rest of the method remains similar)
}

Testing:
- Extend existing unit tests or add new ones to ensure that GetValidSquares returns the correct set of squares for each piece type under various board configurations.

Benefits:

Reduced Complexity: Less code to maintain and debug.
Better Performance: Significantly fewer checks for move validity, especially for pawns and other pieces with limited moves.
Scalability: Makes the game engine more capable of exploring deeper game states efficiently.

Action Items:

Implement GetValidSquares(ChessBoard chessBoard) in each piece subclass.
Refactor IsCheckMate to utilize this new method.
Write comprehensive unit tests for GetValidSquares.

Related Issues:

[Week 7-8: Optimize ChessStateExplorer #11](link to issue)
[Optimize ChessExplorer for depth 7 - Strategy #2 - ChessPiece calculates its own moves #7](link to issue)

Feel free to discuss implementation details, potential pitfalls, or suggest further improvements.

DavidZalewski / chess

Optimize ChessExplorer for depth 7 - Strategy #2 - ChessPiece calculates its own moves. #7

Refactor ChessPiece Move Validation