fix: implement king-safety filtering in getValidMoves to prevent illegal moves

- Add filterMovesLeavingKingInCheck() to simulate moves and reject those leaving king in check
- Extract getCandidateMoves() to avoid infinite recursion with isKingInCheck()
- Update isKingInCheck() to use getCandidateMoves() instead of getValidMoves()
- Enable tests for king moving into check and pinned pieces (both now pass)
- Update castling test to reflect that castling is not yet implemented

This fixes:
- Kings can no longer move into check
- Pinned pieces can no longer move and expose the king
- All pieces respect king safety when calculating valid moves

Co-authored-by: mgierschdev <62764972+mgierschdev@users.noreply.github.com>

Author: Copilot

backend/src/main/java/com/backend/domain/Chessboard.java

@@ -154,7 +154,8 @@ public boolean isKingInCheck(Color color){
             for(int c = 0; c < board[r].length; c++){
                 ChessPiece piece = board[r][c];
                 if(piece.color() == opponent){
-                    Position[] moves = getValidMoves(new Position(r,c));
+                    // Use getCandidateMoves to avoid infinite recursion
+                    Position[] moves = getCandidateMoves(new Position(r,c), piece);
                     for(Position pos : moves){
                         if(pos.row == kingPos.row && pos.col == kingPos.col){
                             return true;
@@ -300,7 +301,21 @@ public Position[] getValidMoves(Position position) {
         }
 
         ChessPiece chessPiece = board[position.row][position.col];
+        Position[] candidateMoves = getCandidateMoves(position, chessPiece);
 
+        // Filter out moves that would leave the player's king in check
+        return filterMovesLeavingKingInCheck(position, candidateMoves, chessPiece.color());
+    }
+
+    /**
+     * Gets candidate moves for a piece without checking king safety.
+     * This is used internally to avoid infinite recursion when checking if king is in check.
+     * 
+     * @param position The position of the piece
+     * @param chessPiece The piece to get moves for
+     * @return Array of candidate moves (may leave king in check)
+     */
+    private Position[] getCandidateMoves(Position position, ChessPiece chessPiece) {
         switch (chessPiece.type()) {
             case Pawn -> {
                 return getValidMovesPawn(position, chessPiece);
@@ -320,8 +335,41 @@ public Position[] getValidMoves(Position position) {
             case Bishop -> {
                 return getValidMovesBishop(position, chessPiece);
             }
+            default -> {
+                return new Position[0];
+            }
+        }
+    }
+
+    /**
+     * Filters out moves that would leave the player's king in check.
+     * Simulates each move and checks if the king is in check after the move.
+     * 
+     * @param from The source position
+     * @param candidateMoves All potential moves for the piece
+     * @param playerColor The color of the player making the move
+     * @return Array of legal moves that don't leave king in check
+     */
+    private Position[] filterMovesLeavingKingInCheck(Position from, Position[] candidateMoves, Color playerColor) {
+        List<Position> legalMoves = new ArrayList<>();
+        
+        for (Position to : candidateMoves) {
+            // Simulate the move
+            ChessPiece captured = simulateMove(from, to);
+            
+            // Check if this move leaves the king in check
+            boolean kingInCheck = isKingInCheck(playerColor);
+            
+            // Undo the move
+            undoMove(from, to, captured);
+            
+            // If the king is not in check after this move, it's legal
+            if (!kingInCheck) {
+                legalMoves.add(to);
+            }
         }
-        return new Position[0];
+        
+        return legalMoves.toArray(Position[]::new);
     }
 
     private Position[] getValidMovesRock(Position position, ChessPiece chessPiece) {

backend/src/test/java/com/backend/domain/ChessRulesTest.java

@@ -21,7 +21,7 @@
 public class ChessRulesTest {
 
     @Test
-    @Disabled("TODO: Implement castling through check validation - current implementation may not prevent this")
+    @Disabled("TODO: Implement castling first, then add validation for castling through check")
     public void testCastlingThroughCheckIsRejected() {
         Chessboard chessboard = new Chessboard();
         ChessPiece[][] board = chessboard.getBoard();
@@ -88,7 +88,6 @@ public void testEnPassantOnlyOnImmediateNextMove() {
     }
 
     @Test
-    @Disabled("TODO: Implement pinned piece validation - current implementation may allow pinned pieces to move")
     public void testPinnedPieceCannotExposeKing() {
         Chessboard chessboard = new Chessboard();
         ChessPiece[][] board = chessboard.getBoard();
@@ -130,7 +129,6 @@ public void testPinnedPieceCannotExposeKing() {
     }
 
     @Test
-    @Disabled("TODO: Verify king cannot move into check - current implementation may have issues with this")
     public void testKingCannotMoveIntoCheck() {
         Chessboard chessboard = new Chessboard();
         ChessPiece[][] board = chessboard.getBoard();