Merge pull request #10 from mgierschdev/codex/add-king-check-and-checkmate-functionality

Add game state evaluation and expose to frontend

Author: mgierschdev

backend/src/main/java/com/backend/ApplicationStart.java

@@ -19,7 +19,7 @@ public static void main(String[] args) {
 
 	public static void startConsoleGame(){
 		ChessGame chessGame = new ChessGame();
-		while(chessGame.gameState != GameState.Checkmate){
+                while(chessGame.getGameState() != GameState.Checkmate){
 			Scanner in = new Scanner(System.in);
 			System.out.println("Move... turn: " + chessGame.getTurn());
 			chessGame.printBoard();

backend/src/main/java/com/backend/controllers/ChessController.java

@@ -6,6 +6,7 @@
 import com.backend.models.ChessPieceType;
 import com.backend.models.Color;
 import com.backend.models.Position;
+import com.backend.models.GameState;
 import com.backend.models.requests.*;
 import com.backend.util.Log;
 import org.springframework.web.bind.annotation.*;
@@ -95,10 +96,12 @@ private void SetChessResponse(){
             chessGameResponse.gameStarted = false;
             chessGameResponse.turn = Color.None;
             chessGameResponse.chessboard = Chessboard.GetArrayBoard(Chessboard.GetInitMatrixBoard());
+            chessGameResponse.gameState = GameState.Free;
             return;
         }
         chessGameResponse.id = requestCount.incrementAndGet();
         chessGameResponse.turn = chessGame.getTurn();
+        chessGameResponse.gameState = chessGame.getGameState();
         chessGameResponse.chessboard = chessGame.getChessboard();
         chessGameResponse.capturedBlack = chessGame.getCaptured(Color.Black);
         chessGameResponse.capturedWhite = chessGame.getCaptured(Color.White);

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

@@ -8,7 +8,7 @@
 import java.util.Set;
 
 public class ChessGame {
-    public final GameState gameState;
+    private GameState gameState;
 
     private final Chessboard chessboard;
 
@@ -68,12 +68,17 @@ public ChessPiece MoveController(Position a, Position b, ChessPieceType promotio
             }
         }
 
-        if (turn == Color.White) {
-            turn = Color.Black;
+        Color nextTurn = turn == Color.White ? Color.Black : Color.White;
+        if (chessboard.isCheckmate(nextTurn)) {
+            gameState = GameState.Checkmate;
+        } else if (chessboard.isKingInCheck(nextTurn)) {
+            gameState = GameState.Check;
         } else {
-            turn = Color.White;
+            gameState = GameState.Free;
         }
 
+        turn = nextTurn;
+
         return chessPiece;
     }
 
@@ -97,6 +102,10 @@ public Color getTurn() {
         return turn;
     }
 
+    public GameState getGameState(){
+        return gameState;
+    }
+
     public Set<ChessPiece> getCaptured(Color color) {
         if (color == Color.White) {
             return takenWhite;

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

@@ -138,6 +138,77 @@ public Position getEnPassantTarget() {
         return enPassantTarget;
     }
 
+    public boolean isKingInCheck(Color color){
+        Position kingPos = findKing(color);
+        if(kingPos == null){
+            return false;
+        }
+        Color opponent = getOpposite(color);
+        for(int r = 0; r < board.length; r++){
+            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));
+                    for(Position pos : moves){
+                        if(pos.row == kingPos.row && pos.col == kingPos.col){
+                            return true;
+                        }
+                    }
+                }
+            }
+        }
+        return false;
+    }
+
+    public boolean isCheckmate(Color color){
+        if(!isKingInCheck(color)){
+            return false;
+        }
+        for(int r = 0; r < board.length; r++){
+            for(int c = 0; c < board[r].length; c++){
+                if(board[r][c].color() == color){
+                    Position from = new Position(r,c);
+                    Position[] moves = getValidMoves(from);
+                    for(Position to : moves){
+                        ChessPiece captured = simulateMove(from, to);
+                        boolean stillCheck = isKingInCheck(color);
+                        undoMove(from, to, captured);
+                        if(!stillCheck){
+                            return false;
+                        }
+                    }
+                }
+            }
+        }
+        return true;
+    }
+
+    private ChessPiece simulateMove(Position from, Position to){
+        ChessPiece moving = board[from.row][from.col];
+        ChessPiece captured = board[to.row][to.col];
+        board[to.row][to.col] = moving;
+        board[from.row][from.col] = emptySpace;
+        return captured;
+    }
+
+    private void undoMove(Position from, Position to, ChessPiece captured){
+        ChessPiece moving = board[to.row][to.col];
+        board[from.row][from.col] = moving;
+        board[to.row][to.col] = captured;
+    }
+
+    private Position findKing(Color color){
+        for(int r = 0; r < board.length; r++){
+            for(int c = 0; c < board[r].length; c++){
+                ChessPiece piece = board[r][c];
+                if(piece.type() == ChessPieceType.King && piece.color() == color){
+                    return new Position(r,c);
+                }
+            }
+        }
+        return null;
+    }
+
     private boolean isValidPromotionType(ChessPieceType type) {
         return type == ChessPieceType.Queen ||
                 type == ChessPieceType.Rock ||

backend/src/main/java/com/backend/models/requests/ChessGameResponse.java

@@ -2,6 +2,7 @@
 
 import com.backend.models.ChessPiece;
 import com.backend.models.Color;
+import com.backend.models.GameState;
 
 import java.util.Set;
 
@@ -13,4 +14,5 @@ public class ChessGameResponse {
     public Set<ChessPiece> capturedBlack;
     public ChessPieceResponse[] chessboard;
     public Color turn;
+    public GameState gameState;
 }

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

@@ -0,0 +1,37 @@
+package com.backend.domain;
+
+import com.backend.models.GameState;
+import com.backend.models.Position;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class GameStateTest {
+
+    @Test
+    public void testCheckScenario() {
+        ChessGame game = new ChessGame();
+
+        // 1. f3 e5 2. e4 Qh4+
+        game.MoveController(new Position(2, 6), new Position(3, 6)); // f2 -> f3
+        game.MoveController(new Position(7, 5), new Position(5, 5)); // e7 -> e5
+        game.MoveController(new Position(2, 5), new Position(4, 5)); // e2 -> e4
+        game.MoveController(new Position(8, 4), new Position(4, 8)); // Qd8 -> h4
+
+        assertEquals(GameState.Check, game.getGameState());
+    }
+
+    @Test
+    public void testCheckmateScenario() {
+        ChessGame game = new ChessGame();
+
+        // 1. f3 e5 2. g4 Qh4#
+        game.MoveController(new Position(2, 6), new Position(3, 6)); // f2 -> f3
+        game.MoveController(new Position(7, 5), new Position(5, 5)); // e7 -> e5
+        game.MoveController(new Position(2, 7), new Position(4, 7)); // g2 -> g4
+        game.MoveController(new Position(8, 4), new Position(4, 8)); // Qd8 -> h4
+
+        assertEquals(GameState.Checkmate, game.getGameState());
+    }
+}
+

frontend/jest.config.js

@@ -0,0 +1,13 @@
+const nextJest = require('next/jest');
+
+const createJestConfig = nextJest({
+    dir: './',
+});
+
+const customJestConfig = {
+    moduleDirectories: ['node_modules', '<rootDir>/'],
+    testEnvironment: 'jsdom',
+};
+
+module.exports = createJestConfig(customJestConfig);
+