adding castling

src/backend/Board.java

@@ -23,6 +23,16 @@ public class Board {
 		this.lineNum = lineNum;
 		this.board = new Piece[lineNum][colNum];
 	}
+	
+	public Set<String> getAllMoves(boolean isWhite) {
+	    Set<String> allMoves = new HashSet<>();
+	    for (Piece piece : getPieces()) {
+	        if (piece.isWhite() == isWhite) {
+	            allMoves.addAll(getValidMoves(piece, true));
+	        }
+	    }
+	    return allMoves;
+	}
 
 	public int getWidth() { 
 		return colNum; 
@@ -119,15 +129,25 @@ public class Board {
 				selectedPiece = p;
 				highlightedPositions = getValidMoves(p);
 			}
-		} else {
+		} 
-			if (highlightedPositions.contains(x + "," + y)) {
+		else {
-				movePiece(selectedPiece.getX(), selectedPiece.getY(), x, y);
+	        String targetPos = x + "," + y;
-				isWhiteTurn = !isWhiteTurn;
+	        if (highlightedPositions.contains(targetPos)) {
-				turnNumber++;
+	            if (selectedPiece.getType() == PieceType.King && Math.abs(x - selectedPiece.getX()) == 2) {
-			}
+	                // Castling move
-			selectedPiece = null;
+	                Castling castlingHandler = new Castling(this);
-			highlightedPositions.clear();
+	                int rookX = (x > selectedPiece.getX()) ? 7 : 0;
-		}
+	                castlingHandler.performCastle(selectedPiece, rookX, y);
+	            } else {
+	                // Normal move
+	                movePiece(selectedPiece.getX(), selectedPiece.getY(), x, y);
+	            }
+	            isWhiteTurn = !isWhiteTurn;
+	            turnNumber++;
+	        }
+	        selectedPiece = null;
+	        highlightedPositions.clear();
+	    }
 	}
 
 	public boolean isSelected(int x, int y) {
@@ -264,6 +284,15 @@ public class Board {
 	                    }
 	                }
 	            }
+	            
+	            Castling castlingHandler = new Castling(this);
+	            for (int rookX : new int[]{0, 7}) {
+	                if (castlingHandler.canCastle(piece, rookX, y)) {
+	                    int newKingX = (rookX > x) ? x + 2 : x - 2;
+	                    validMoves.add(newKingX + "," + y);
+	                }
+	            }
+	            
 	            break;
 	    }
 

src/backend/Castling.java

@@ -0,0 +1,65 @@
+package backend;
+
+import java.util.Set;
+
+public class Castling {
+
+    private Board board;
+
+    public Castling(Board board) {
+        this.board = board;
+    }
+
+    public boolean canCastle(Piece king, int rookX, int rookY) {
+        if (king.getType() != PieceType.King) return false;
+        if (king.isWhite() != board.isTurnWhite()) return false;
+
+        int kingY = king.getY();
+        int kingX = king.getX();
+
+        Piece rook = board.getBoardMatrix()[rookY][rookX];
+        if (rook == null || rook.getType() != PieceType.Rook) return false;
+        if (rook.isWhite() != king.isWhite()) return false;
+
+        if (isPathClear(kingX, rookX, kingY) && !isInCheck(king)) {
+            int direction = (rookX > kingX) ? 1 : -1;
+            for (int i = 1; i <= 2; i++) {
+                int x = kingX + (i * direction);
+                Piece tempKing = new Piece(x, kingY, PieceType.King, king.isWhite());
+                if (isInCheck(tempKing)) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        return false;
+    }
+
+    private boolean isPathClear(int startX, int endX, int y) {
+        int step = (endX > startX) ? 1 : -1;
+        for (int x = startX + step; x != endX; x += step) {
+            if (board.getBoardMatrix()[y][x] != null) return false;
+        }
+        return true;
+    }
+
+    private boolean isInCheck(Piece king) {
+        Set<String> opponentMoves = board.getAllMoves(!king.isWhite());
+        String kingPos = king.getX() + "," + king.getY();
+        return opponentMoves.contains(kingPos);
+    }
+
+    public void performCastle(Piece king, int rookX, int rookY) {
+        if (!canCastle(king, rookX, rookY)) return;
+
+        int kingY = king.getY();
+        int kingX = king.getX();
+        int direction = (rookX > kingX) ? 1 : -1;
+
+        int newKingX = kingX + (2 * direction);
+        int newRookX = kingX + direction;
+
+        board.movePiece(kingX, kingY, newKingX, kingY);
+        board.movePiece(rookX, rookY, newRookX, kingY);
+    }
+}