Hi there, Programmers. Welcome to ayanhacks blog. This post will teach us how to use C++ (with source code) to develop a chess game. Starting a game development adventure can spark creativity and increase one’s comprehension of the complexities of programming. When it comes to board games with a strategic element, Chess is a timeless classic that tests the ability of both the mind and algorithms.
We Explore the Intriguing Realm of Using C++ to Create a Chess Game Using C++ in This Blog Post. This Project Offers an Enriching Investigation of Object-oriented Programming, Algorithmic Logic, and the Pleasure of Bringing a Strategic Masterpiece to Life in Code, Appealing to Both Seasoned Programmers Looking for a Fresh Project and Enthusiastic Learners.
What is a C++ Chess game, and how is it made?
Two players can play a game of chess. It’s software that lets two people use a computer to play chess. To play, a virtual chessboard must be created, and each player is given a set of pieces to move across the board alternately. The object of the game is to place the opponent’s king in checkmate and adhere to standard chess concepts, which include piece movement and capture of enemy pieces.
The object-oriented programming notion of classes will be used to develop this project. The game can be accessed through a graphical user interface (GUI), which is more visually appealing and easier to use than a command-line interface.
In general, creating a chess game in C++ involves writing the rules and logic of the game and applying object-oriented programming techniques to create a flexible and effective software that can respond to many game scenarios and user inputs.
Overview of the UI:
Welcome to Chess Game Developed by Cppsecrets Keys to symbols used * = white space Blank space = black space WP = White pawn & BP = Black pawn WN = White Knight & BN = Black Knight WB = White Bishop & BB = Black Bishop WR = White Rook & BR = Black Rook WQ = White Queen & BQ = Black Queen WK = White King & BK =Black King
To carry out the desired action, the user will select an option. To complete that process, the user will then input data in response to the prompts that appear on the terminal.
Other Projects:
- 10+ HTML CSS Projects With Source Code
- Create Neon Heart With HTML and CSS
- 10 Button Hover Effects Using CSS
- Christmas Animation Effects Using HTML And CSS
- Expanding Card Source Code with HTML, CSS & JavaScript
Chess Game in C++ Source Code
You can copy this code into your IDE and use it immediately to see how it works before creating it by studying the project.
#include <iostream>
#include <stdlib.h>
class GamePiece
{
public:
GamePiece(char PieceColor) : mPieceColor(PieceColor) {}
~GamePiece() {}
virtual char GetPiece() = 0;
char GetColor() {
return mPieceColor;
}
bool IsLegalMove(int iSrcRow, int iSrcCol, int iDestRow, int iDestCol, GamePiece* GameBoard[8][8]) {
GamePiece* qpDest = GameBoard[iDestRow][iDestCol];
if ((qpDest == 0) || (mPieceColor != qpDest->GetColor())) {
return AreSquaresLegal(iSrcRow, iSrcCol, iDestRow, iDestCol, GameBoard);
}
return false;
}
private:
virtual bool AreSquaresLegal(int iSrcRow, int iSrcCol, int iDestRow, int iDestCol, GamePiece* GameBoard[8][8]) = 0;
char mPieceColor;
};
class PawnPiece : public GamePiece
{
public:
PawnPiece(char PieceColor) : GamePiece(PieceColor) {}
~PawnPiece() {}
private:
virtual char GetPiece() {
return 'P';
}
bool AreSquaresLegal(int iSrcRow, int iSrcCol, int iDestRow, int iDestCol, GamePiece* GameBoard[8][8]) {
GamePiece* qpDest = GameBoard[iDestRow][iDestCol];
if (qpDest == 0) {
// Destination square is unoccupied
if (iSrcCol == iDestCol) {
if (GetColor() == 'W') {
if (iDestRow == iSrcRow + 1) {
return true;
}
} else {
if (iDestRow == iSrcRow - 1) {
return true;
}
}
}
} else {
// Dest holds piece of opposite color
if ((iSrcCol == iDestCol + 1) || (iSrcCol == iDestCol - 1)) {
if (GetColor() == 'W') {
if (iDestRow == iSrcRow + 1) {
return true;
}
} else {
if (iDestRow == iSrcRow - 1) {
return true;
}
}
}
}
return false;
}
};
class KnightPiece : public GamePiece
{
public:
KnightPiece(char PieceColor) : GamePiece(PieceColor) {}
~KnightPiece() {}
private:
virtual char GetPiece() {
return 'N';
}
bool AreSquaresLegal(int iSrcRow, int iSrcCol, int iDestRow, int iDestCol, GamePiece* GameBoard[8][8]) {
// Destination square is unoccupied or occupied by opposite color
if ((iSrcCol == iDestCol + 1) || (iSrcCol == iDestCol - 1)) {
if ((iSrcRow == iDestRow + 2) || (iSrcRow == iDestRow - 2)) {
return true;
}
}
if ((iSrcCol == iDestCol + 2) || (iSrcCol == iDestCol - 2)) {
if ((iSrcRow == iDestRow + 1) || (iSrcRow == iDestRow - 1)) {
return true;
}
}
return false;
}
};
class BishopPiece : public GamePiece
{
public:
BishopPiece(char PieceColor) : GamePiece(PieceColor) {}
~BishopPiece() {}
private:
virtual char GetPiece() {
return 'B';
}
bool AreSquaresLegal(int iSrcRow, int iSrcCol, int iDestRow, int iDestCol, GamePiece* GameBoard[8][8]) {
if ((iDestCol - iSrcCol == iDestRow - iSrcRow) || (iDestCol - iSrcCol == iSrcRow - iDestRow)) {
// Make sure that all invervening squares are empty
int iRowOffset = (iDestRow - iSrcRow > 0) ? 1 : -1;
int iColOffset = (iDestCol - iSrcCol > 0) ? 1 : -1;
int iCheckRow;
int iCheckCol;
for (iCheckRow = iSrcRow + iRowOffset, iCheckCol = iSrcCol + iColOffset;
iCheckRow != iDestRow;
iCheckRow = iCheckRow + iRowOffset, iCheckCol = iCheckCol + iColOffset)
{
if (GameBoard[iCheckRow][iCheckCol] != 0) {
return false;
}
}
return true;
}
return false;
}
};
class RookPiece : public GamePiece
{
public:
RookPiece(char PieceColor) : GamePiece(PieceColor) {}
~RookPiece() {}
private:
virtual char GetPiece() {
return 'R';
}
bool AreSquaresLegal(int iSrcRow, int iSrcCol, int iDestRow, int iDestCol, GamePiece* GameBoard[8][8]) {
if (iSrcRow == iDestRow) {
// Make sure that all invervening squares are empty
int iColOffset = (iDestCol - iSrcCol > 0) ? 1 : -1;
for (int iCheckCol = iSrcCol + iColOffset; iCheckCol != iDestCol; iCheckCol = iCheckCol + iColOffset) {
if (GameBoard[iSrcRow][iCheckCol] != 0) {
return false;
}
}
return true;
} else if (iDestCol == iSrcCol) {
// Make sure that all invervening squares are empty
int iRowOffset = (iDestRow - iSrcRow > 0) ? 1 : -1;
for (int iCheckRow = iSrcRow + iRowOffset; iCheckRow != iDestRow; iCheckRow = iCheckRow + iRowOffset) {
if (GameBoard[iCheckRow][iSrcCol] != 0) {
return false;
}
}
return true;
}
return false;
}
};
class QueenPiece : public GamePiece
{
public:
QueenPiece(char PieceColor) : GamePiece(PieceColor) {}
~QueenPiece() {}
private:
virtual char GetPiece() {
return 'Q';
}
bool AreSquaresLegal(int iSrcRow, int iSrcCol, int iDestRow, int iDestCol, GamePiece* GameBoard[8][8]) {
if (iSrcRow == iDestRow) {
// Make sure that all invervening squares are empty
int iColOffset = (iDestCol - iSrcCol > 0) ? 1 : -1;
for (int iCheckCol = iSrcCol + iColOffset; iCheckCol != iDestCol; iCheckCol = iCheckCol + iColOffset) {
if (GameBoard[iSrcRow][iCheckCol] != 0) {
return false;
}
}
return true;
} else if (iDestCol == iSrcCol) {
// Make sure that all invervening squares are empty
int iRowOffset = (iDestRow - iSrcRow > 0) ? 1 : -1;
for (int iCheckRow = iSrcRow + iRowOffset; iCheckRow != iDestRow; iCheckRow = iCheckRow + iRowOffset) {
if (GameBoard[iCheckRow][iSrcCol] != 0) {
return false;
}
}
return true;
} else if ((iDestCol - iSrcCol == iDestRow - iSrcRow) || (iDestCol - iSrcCol == iSrcRow - iDestRow)) {
// Make sure that all invervening squares are empty
int iRowOffset = (iDestRow - iSrcRow > 0) ? 1 : -1;
int iColOffset = (iDestCol - iSrcCol > 0) ? 1 : -1;
int iCheckRow;
int iCheckCol;
for (iCheckRow = iSrcRow + iRowOffset, iCheckCol = iSrcCol + iColOffset;
iCheckRow != iDestRow;
iCheckRow = iCheckRow + iRowOffset, iCheckCol = iCheckCol + iColOffset)
{
if (GameBoard[iCheckRow][iCheckCol] != 0) {
return false;
}
}
return true;
}
return false;
}
};
class KingPiece : public GamePiece
{
public:
KingPiece(char PieceColor) : GamePiece(PieceColor) {}
~KingPiece() {}
private:
virtual char GetPiece() {
return 'K';
}
bool AreSquaresLegal(int iSrcRow, int iSrcCol, int iDestRow, int iDestCol, GamePiece* GameBoard[8][8]) {
int iRowDelta = iDestRow - iSrcRow;
int iColDelta = iDestCol - iSrcCol;
if (((iRowDelta >= -1) && (iRowDelta <= 1)) &&
((iColDelta >= -1) && (iColDelta <= 1)))
{
return true;
}
return false;
}
};
class CBoard
{
public:
CBoard() {
for (int iRow = 0; iRow < 8; ++iRow) {
for (int iCol = 0; iCol < 8; ++iCol) {
MainGameBoard[iRow][iCol] = 0;
}
}
// Allocate and place black pieces
for (int iCol = 0; iCol < 8; ++iCol) {
MainGameBoard[6][iCol] = new PawnPiece('B');
}
MainGameBoard[7][0] = new RookPiece('B');
MainGameBoard[7][1] = new KnightPiece('B');
MainGameBoard[7][2] = new BishopPiece('B');
MainGameBoard[7][3] = new KingPiece('B');
MainGameBoard[7][4] = new QueenPiece('B');
MainGameBoard[7][5] = new BishopPiece('B');
MainGameBoard[7][6] = new KnightPiece('B');
MainGameBoard[7][7] = new RookPiece('B');
// Allocate and place white pieces
for (int iCol = 0; iCol < 8; ++iCol) {
MainGameBoard[1][iCol] = new PawnPiece('W');
}
MainGameBoard[0][0] = new RookPiece('W');
MainGameBoard[0][1] = new KnightPiece('W');
MainGameBoard[0][2] = new BishopPiece('W');
MainGameBoard[0][3] = new KingPiece('W');
MainGameBoard[0][4] = new QueenPiece('W');
MainGameBoard[0][5] = new BishopPiece('W');
MainGameBoard[0][6] = new KnightPiece('W');
MainGameBoard[0][7] = new RookPiece('W');
}
~CBoard() {
for (int iRow = 0; iRow < 8; ++iRow) {
for (int iCol = 0; iCol < 8; ++iCol) {
delete MainGameBoard[iRow][iCol];
MainGameBoard[iRow][iCol] = 0;
}
}
}
void Print() {
using namespace std;
const int kiSquareWidth = 4;
const int kiSquareHeight = 3;
for (int iRow = 0; iRow < 8*kiSquareHeight; ++iRow) {
int iSquareRow = iRow/kiSquareHeight;
// Print side border with numbering
if (iRow % 3 == 1) {
cout << '-' << (char)('1' + 7 - iSquareRow) << '-';
} else {
cout << "---";
}
// Print the chess board
for (int iCol = 0; iCol < 8*kiSquareWidth; ++iCol) {
int iSquareCol = iCol/kiSquareWidth;
if (((iRow % 3) == 1) && ((iCol % 4) == 1 || (iCol % 4) == 2) && MainGameBoard[7-iSquareRow][iSquareCol] != 0) {
if ((iCol % 4) == 1) {
cout << MainGameBoard[7-iSquareRow][iSquareCol]->GetColor();
} else {
cout << MainGameBoard[7-iSquareRow][iSquareCol]->GetPiece();
}
} else {
if ((iSquareRow + iSquareCol) % 2 == 1) {
cout << '*';
} else {
cout << ' ';
}
}
}
cout << endl;
}
// Print the bottom border with numbers
for (int iRow = 0; iRow < kiSquareHeight; ++iRow) {
if (iRow % 3 == 1) {
cout << "---";
for (int iCol = 0; iCol < 8*kiSquareWidth; ++iCol) {
int iSquareCol = iCol/kiSquareWidth;
if ((iCol % 4) == 1) {
cout << (iSquareCol + 1);
} else {
cout << '-';
}
}
cout << endl;
} else {
for (int iCol = 1; iCol < 9*kiSquareWidth; ++iCol) {
cout << '-';
}
cout << endl;
}
}
}
bool IsInCheck(char PieceColor) {
// Find the king
int iKingRow;
int iKingCol;
for (int iRow = 0; iRow < 8; ++iRow) {
for (int iCol = 0; iCol < 8; ++iCol) {
if (MainGameBoard[iRow][iCol] != 0) {
if (MainGameBoard[iRow][iCol]->GetColor() == PieceColor) {
if (MainGameBoard[iRow][iCol]->GetPiece() == 'K') {
iKingRow = iRow;
iKingCol = iCol;
}
}
}
}
}
// Run through the opponent's pieces and see if any can take the king
for (int iRow = 0; iRow < 8; ++iRow) {
for (int iCol = 0; iCol < 8; ++iCol) {
if (MainGameBoard[iRow][iCol] != 0) {
if (MainGameBoard[iRow][iCol]->GetColor() != PieceColor) {
if (MainGameBoard[iRow][iCol]->IsLegalMove(iRow, iCol, iKingRow, iKingCol, MainGameBoard)) {
return true;
}
}
}
}
}
return false;
}
bool CanMove(char PieceColor) {
// Run through all pieces
for (int iRow = 0; iRow < 8; ++iRow) {
for (int iCol = 0; iCol < 8; ++iCol) {
if (MainGameBoard[iRow][iCol] != 0) {
// If it is a piece of the current player, see if it has a legal move
if (MainGameBoard[iRow][iCol]->GetColor() == PieceColor) {
for (int iMoveRow = 0; iMoveRow < 8; ++iMoveRow) {
for (int iMoveCol = 0; iMoveCol < 8; ++iMoveCol) {
if (MainGameBoard[iRow][iCol]->IsLegalMove(iRow, iCol, iMoveRow, iMoveCol, MainGameBoard)) {
// Make move and check whether king is in check
GamePiece* qpTemp = MainGameBoard[iMoveRow][iMoveCol];
MainGameBoard[iMoveRow][iMoveCol] = MainGameBoard[iRow][iCol];
MainGameBoard[iRow][iCol] = 0;
bool bCanMove = !IsInCheck(PieceColor);
// Undo the move
MainGameBoard[iRow][iCol] = MainGameBoard[iMoveRow][iMoveCol];
MainGameBoard[iMoveRow][iMoveCol] = qpTemp;
if (bCanMove) {
return true;
}
}
}
}
}
}
}
}
return false;
}
GamePiece* MainGameBoard[8][8];
};
class ChessBoard
{
public:
ChessBoard() : mcPlayerTurn('W') {}
~ChessBoard() {}
void Start() {
do {
GetNextMove(mqGameBoard.MainGameBoard);
AlternateTurn();
} while (!IsGameOver());
mqGameBoard.Print();
}
void GetNextMove(GamePiece* GameBoard[8][8]) {
using namespace std;
bool bValidMove = false;
do {
system ("clear");
cout<<endl<<endl<<" Welcome to Chess Game Developed by Cppsecrets "<<endl<<endl<<endl;
cout<<" Keys to sysmbols used "<<endl<<endl<<endl;
cout<<" * = white space"<<endl;
cout<<" Blank space = black space"<<endl;
cout<<" WP = White pawn & BP = Black pawn"<<endl;
cout<<" WN = White Knight & BN = Black Knight"<<endl;
cout<<" WB = White Bishop & BB = Black Bishop"<<endl;
cout<<" WR = White Rook & BR = Black Rook"<<endl;
cout<<" WQ = White Queen & BQ = Black Queen"<<endl;
cout<<" WK = White King & BK =Black King"<<endl;
cout<<"Rule for move is :"<<endl;
cout<<"Move by selecting row & column to another valid location using row & column"<<endl<<endl<<endl;
mqGameBoard.Print();
// Get input and convert to coordinates
cout << mcPlayerTurn << "'s Move: ";
int iStartMove;
cin >> iStartMove;
int iStartRow = (iStartMove / 10) - 1;
int iStartCol = (iStartMove % 10) - 1;
cout << "To: ";
int iEndMove;
cin >> iEndMove;
int iEndRow = (iEndMove / 10) - 1;
int iEndCol = (iEndMove % 10) - 1;
// Check that the indices are in range
// and that the source and destination are different
if ((iStartRow >= 0 && iStartRow <= 7) &&
(iStartCol >= 0 && iStartCol <= 7) &&
(iEndRow >= 0 && iEndRow <= 7) &&
(iEndCol >= 0 && iEndCol <= 7)) {
// Additional checks in here
GamePiece* qpCurrPiece = GameBoard[iStartRow][iStartCol];
// Check that the piece is the correct color
if ((qpCurrPiece != 0) && (qpCurrPiece->GetColor() == mcPlayerTurn)) {
// Check that the destination is a valid destination
if (qpCurrPiece->IsLegalMove(iStartRow, iStartCol, iEndRow, iEndCol, GameBoard)) {
// Make the move
GamePiece* qpTemp = GameBoard[iEndRow][iEndCol];
GameBoard[iEndRow][iEndCol] = GameBoard[iStartRow][iStartCol];
GameBoard[iStartRow][iStartCol] = 0;
// Make sure that the current player is not in check
if (!mqGameBoard.IsInCheck(mcPlayerTurn)) {
delete qpTemp;
bValidMove = true;
} else { // Undo the last move
GameBoard[iStartRow][iStartCol] = GameBoard[iEndRow][iEndCol];
GameBoard[iEndRow][iEndCol] = qpTemp;
}
}
}
}
if (!bValidMove) {
cout << "Invalid Move!" << endl;
}
} while (!bValidMove);
}
void AlternateTurn() {
mcPlayerTurn = (mcPlayerTurn == 'W') ? 'B' : 'W';
}
bool IsGameOver() {
// Check that the current player can move
// If not, we have a stalemate or checkmate
bool bCanMove(false);
bCanMove = mqGameBoard.CanMove(mcPlayerTurn);
if (!bCanMove) {
if (mqGameBoard.IsInCheck(mcPlayerTurn)) {
AlternateTurn();
std::cout << "Checkmate, " << mcPlayerTurn << " Wins!" << std::endl;
} else {
std::cout << "Stalemate!" << std::endl;
}
}
return !bCanMove;
}
private:
CBoard mqGameBoard;
char mcPlayerTurn;
};
int main() {
ChessBoard qGame;
qGame.Start();
return 0;
}Let’s now examine the code:
- Using the necessary libraries, iostream (input and output stream) and stdlib.h (memory management), we will first write the code’s header.
- For this project, we will be developing the following classes: Pawn, Knight, Bishop, Rook, Game, and Queen pieces included
- The common data and functionalities that all of the game’s pieces will share are contained in the GamePiece class. This class will have a constructor that initializes the member variable mPieceColor and accepts a char argument called PieceColor. In this class, we’ll build a virtual function named GetPiece() that yields a char that represents the piece’s type. The source and destination locations of a move, as well as a pointer to a two-dimensional array GameBoard that represents the game’s current state, will be entered into the boolean function IsLegalMove(). The function determines whether the move is permitted and returns a boolean value indicating the move’s legality.
- The GetPiece() function will be overridden by the derived classes from the base class, GamePiece, and they will then return the appropriate character for each type of piece. The if-else control statements are used.
- The if-else statement in the PawnPiece class determines whether the destination square is occupied or contains a piece of the opposite color.
- The nested if statement is used for the knightPiece class to determine whether the destination square is empty or occupied by a color that is opposite to it.
- We will verify that any intervening squares for the BishopPiece class are empty. We will also check the destination row, rows, and columns.
- Similarly, we will specify each piece’s functioning and how it will move following its predetermined regulations to go to its destination.
- Using a for loop, we will assign and arrange the black pieces in the CBoard class as well as the white pieces. We’ll assign various pieces to their appropriate chessboard locations.
- An image of the chess board will be printed onto the console via the Print() function. The width and height of each square on the board will essentially be determined by using the two constants, kiSquareWidth and kiSquareHeight. It prints out the appropriate characters to represent the border, numbers, and chess pieces as it moves across the rows and columns of the board.
- Using a PieceColor parameter of either “w” or “b,” the boolean type IsInCheck() function detects whether the king of that color is now under control. It moves around the board to see if any pieces belonging to the opposition can legitimately advance to the square where the king is located. It returns true if this is the case. It returns false otherwise.
- To determine whether any pieces of a certain color have a legitimate move on the current board, the boolean CanMove() function looks at the PieceColor parameter. Every square on the board will be cycled through, and it will look for any legitimate moves that prevent the king of that color from being checked for every piece of that color.
- The board that will be used to play chess will be displayed on a class chessboard that we make. implementing a do/while loop to initiate the game by creating the start() function. After creating the GetNextMove() function, the screen is cleared, a welcome message is shown, and keys to the game’s symbols are displayed. After receiving the input, we shall transform it to coordinates.
- Next, we’ll make sure the source and destination are distinct and the indices are within range. After making the transfer, we will utilize if statements to perform further checks on the piece color and validity of destination.
- If the present player can move, then there is a stalemate or checkmate, as determined by the boolean type IsGameOver() function. After that, the game will end.
- To begin the chess game, the main() method invokes the start(0) function.
- This concludes our C++ chess game project.
Final Output:
Here is an example to show how this project works.
In Conclusion
In conclusion, creating a C++ chess game has shown to be a fun and instructive project. The complex logic and techniques needed to enable features like piece movement, checkmate detection, and user interface interaction are reflected in the source code. This project deepens one’s grasp of data structures, object-oriented programming concepts, and the challenges of designing a strategic board game.
In addition, the source code for the Chess game offers an excellent starting point for anyone interested in game development and programming and is a great learning tool. All things considered, this project is a prime example of the combination of creativity and logic, providing both prospective game developers and C++ enthusiasts with an extensive learning experience.
[…] Chess Game Using C++ with Source Code […]