Chess Game in Java

What is chess game?

In java, chess is a board game that play between two players both players compete with each other. In chess we have a square checkerboard that has 64 squares with varying colours. Basically chess is a strategic game that is played by millions of people worldwide.

So in other words, chess is a strategic board game in which chess player try to checkmate their opponent kings. They try to checkmate kings in a vulnerable positions so the king can’t escape, capture or mount an attack. In chess, we have one king, one queen, two rooks, two horse, two bishops and eight set of pawns in total we have 16 piece initially. At the start of the game, the pieces are arranged in a precise way on the board.

Each component moves in accordance with predetermined guidelines. The movements of each piece are described in the following manner:

• King: The king is the only player who has the ability to move one square in any direction, including diagonally. The game is over if the valuable piece known as the king is checkmated.
• Queen: The most powerful piece is the queen. It has the ability to move any quantity of squares in any plane—horizontal, vertical, or diagonal.
• Rook: The rook is able to move any quantity of squares either horizontally or vertically. It can't cross over other pieces.
• Bishop: Any number of squares may be moved diagonally by the bishop. It can't cross over other pieces. Each player begins the game with one bishop on a dark square and one on a light square.
• Knight: Moving in an L-shape, the knight first moves two squares in one way (either horizontally or vertically), then one square in the opposite direction. The only piece that has the ability to "jump" over other pieces is the knight.
• Pawn: The least powerful but most common piece is the pawn. They advance one square, but they are diagonally captured. They can choose to advance one or two squares on their first move. En passant is a unique move that pawns can use to capture an enemy piece that has just advanced two squares.

Each player takes a turn moving a piece, with the white player initiating play. A player may move one of their pieces during their turn in accordance with that piece's movement rules. By placing their own pieces in the squares that the enemy's pieces are occupying, the players can take their opponent's pieces.

The opponent's king is under attack and cannot flee capture, and the game is not over until one player achieves checkmate. However, if certain criteria are met, such as when there isn't enough material to checkmate or when both players consent to a draw, the game may end in a draw or stalemate.

Chess requires tactical manoeuvres, strategic planning, and strategic thinking. Players must foresee their rivals' moves, safeguard their own pieces, maintain control of the centre of the board, and establish favourable positions.

Development of chess game in java

In java development of chess game is a complex task. But we can have an overview of development process of chess game in java.

There are some keys points:

• Board representation: Consider how you want to represent the chessboard and the pieces in your code. The board can be represented using a 2D array, matrix, or other data structures.
• Piece movement: Implement the movement guidelines for each chess piece. Establish strategies for validating moves and dealing with the capture of enemy pieces.
• Game Logic: Establish game logic to control turns, validate moves, and monitor for checkmate, stalemate, and draw situations. Apply the castling, en passant, pawn promotion, and other special move regulations.
• User interface: Make a choice regarding your chess game's user interface. Both command-line interfaces and graphical user interfaces (GUI) are acceptable. You can use Java Swing, JavaFX, or a library like LibGDX to create a GUI.
• Input handling: Implement the code to handle user input for moves, such as selecting squares in a graphical user interface (GUI) or entering coordinates in a command-line interface. Convert user input into the corresponding chessboard moves.
• Game State Management: Keep track of and update the game's current state, including the pieces' positions, the current player's turn, the pieces that have been captured, and any other relevant data.
• AI Opponent (Optional): it is an optional feature but you can use an AI algorithm like minimax with alpha-beta pruning to build a computer opponent. The AI should assess the current situation, look for the best moves, and then take appropriate action.
• Testing and debugging: Test and debug your chess game thoroughly to make sure that the rules and moves are applied correctly. To verify the behaviour of the game, test various scenarios and edge cases.
• Refinement and Enhancement: Make continuous code improvements, user interface improvements, and feature additions like game saving/loading, move history display, hinting, or multiplayer functionality.

It's important to remember to break down the development process into smaller tasks, complete each one individually, and test your code gradually. To ensure accurate application, it's also beneficial to consult the chess rules and available materials.

Source code

```import java.util.Scanner;
public class ChessGame {
private static final int BOARD_SIZE = 8;
private static char[][] board;
public static void main(String[] args) {
board = new char[BOARD_SIZE][BOARD_SIZE];
initializeBoard();
Scanner scanner = new Scanner(System.in);
boolean gameOver = false;
boolean whiteTurn = true;
while (!gameOver) {
printBoard();
char player = whiteTurn ? 'W' : 'B';
System.out.print("Player " + player + ", enter your move (e.g., 'a2 a4'): ");
String move = scanner.nextLine();
if (move.equalsIgnoreCase("quit")) {
System.out.println("Game over. Quitting...");
gameOver = true;
break;
}
String[] moveParts = move.split(" ");
String fromPosition = moveParts[0];
String toPosition = moveParts[1];
int fromRow = 8 - Character.getNumericValue(fromPosition.charAt(1));
int fromCol = fromPosition.charAt(0) - 'a';
int toRow = 8 - Character.getNumericValue(toPosition.charAt(1));
int toCol = toPosition.charAt(0) - 'a';
if (isValidMove(fromRow, fromCol, toRow, toCol, player)) {
makeMove(fromRow, fromCol, toRow, toCol);
whiteTurn = !whiteTurn;
} else {
System.out.println("Invalid move. Try again.");
}
}
scanner.close();
}
private static void initializeBoard() {
// Set up the initial chess board
board[0] = new char[] {'r', 'n', 'b', 'q', 'k', 'b', 'n', 'r'};
board[1] = new char[] {'p', 'p', 'p', 'p', 'p', 'p', 'p', 'p'};
board[6] = new char[] {'P', 'P', 'P', 'P', 'P', 'P', 'P', 'P'};
board[7] = new char[] {'R', 'N', 'B', 'Q', 'K', 'B', 'N', 'R'};
for (int i = 2; i < 6; i++) {
board[i] = new char[BOARD_SIZE];
for (int j = 0; j < BOARD_SIZE; j++) {
board[i][j] = '-';
}
}
}
private static void printBoard() {
System.out.println("\n a b c d e f g h");
for (int i = 0; i < BOARD_SIZE; i++) {
System.out.print((8 - i) + " ");
for (int j = 0; j < BOARD_SIZE; j++) {
System.out.print(board[i][j] + " ");
}
System.out.println(" " + (8 - i));
}
System.out.println(" a b c d e f g h\n");
}
private static boolean isValidMove(int fromRow, int fromCol, int toRow, int toCol, char player) {
// Check if the move is within the board boundaries
if (fromRow < 0 || fromRow >= BOARD_SIZE || fromCol < 0 || fromCol >= BOARD_SIZE ||
toRow < 0 || toRow >= BOARD_SIZE || toCol < 0 || toCol >= BOARD_SIZE) {
return false;
}
// Check if the player is moving their own piece
if (Character.isUpperCase(player) && Character.isLowerCase(board[fromRow][fromCol])) {
return false;
}
if (Character.isLowerCase(player) && Character.isUpperCase(board[fromRow][fromCol])) {
return false;
}
// Check if the move is valid for the specific piece
char piece = Character.toLowerCase(board[fromRow][fromCol]);
switch (piece) {
case 'p':
// TODO: Implement pawn movement rules
break;
case 'r':
// TODO: Implement rook movement rules
break;
case 'n':
// TODO: Implement knight movement rules
break;
case 'b':
// TODO: Implement bishop movement rules
break;
case 'q':
// TODO: Implement queen movement rules
break;
case 'k':
// TODO: Implement king movement rules
break;
default:
return false;
}
return true;
}
private static void makeMove(int fromRow, int fromCol, int toRow, int toCol) {
board[toRow][toCol] = board[fromRow][fromCol];
board[fromRow][fromCol] = '-';
}
}
```

Please be aware that this is a simple implementation that only controls piece movement on the board. The game does not handle checks, checkmates, or other game-ending situations, nor does it implement the rules and logic for individual pieces (such as the pawn, rook, knight, etc.). You must implement the particular movement guidelines for each piece and, as necessary, add more game logic to finish the code.