├── .gitattributes
├── .gitignore
└── chess.cpp


/.gitattributes:
--------------------------------------------------------------------------------
1 | # Auto detect text files and perform LF normalization
2 | * text=auto
3 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | # Prerequisites
 2 | *.d
 3 | 
 4 | # Compiled Object files
 5 | *.slo
 6 | *.lo
 7 | *.o
 8 | *.obj
 9 | 
10 | # Precompiled Headers
11 | *.gch
12 | *.pch
13 | 
14 | # Compiled Dynamic libraries
15 | *.so
16 | *.dylib
17 | *.dll
18 | 
19 | # Fortran module files
20 | *.mod
21 | *.smod
22 | 
23 | # Compiled Static libraries
24 | *.lai
25 | *.la
26 | *.a
27 | *.lib
28 | 
29 | # Executables
30 | *.exe
31 | *.out
32 | *.app
33 | 


--------------------------------------------------------------------------------
/chess.cpp:
--------------------------------------------------------------------------------
   1 | #include<iostream>
   2 | #include<cstring>
   3 | #include<conio.h>
   4 | #include<dos.h>
   5 | #include<Windows.h>
   6 | #include<fstream>
   7 | #include<iomanip>
   8 | #include<stdlib.h>
   9 | #include<ctime>
  10 | using namespace std;
  11 | 
  12 | //*******************************************|           GLOBAL VARIABLES            |***************************************
  13 | char turn = 'A';    //for turns
  14 | 
  15 | //for time couner
  16 | int rapidTimerA = 600, rapidTimerB = 600;
  17 | int blitzTimerA = 300, blitzTimerB = 300;
  18 | int classicTimerA = 0, classicTimerB = 0;
  19 | int hourA=0, minA=0, secA=0;
  20 | int hourB=0, minB=0, secB=0;
  21 | 
  22 | //for check on player White & Black
  23 | bool checkA = false, checkB = false;
  24 | 
  25 | //for storing previous moves position
  26 | int prevCoordinate[8] = { 9,9,9,9,9,9,9,9 };
  27 | 
  28 | //contain opposite pieces
  29 | char opposite[6];
  30 | 
  31 | 
  32 | int checkInd[100] = {};
  33 | int storeCheckPieceInd[100] = {}, foolmateA = 0, foolmateB = 0;
  34 | 
  35 | //for replay file
  36 | fstream saveFile1("save1.txt");
  37 | fstream saveFile2("save2.txt");
  38 | fstream saveFile3("save3.txt");
  39 | 
  40 | char saveMoves[10000] = {0};
  41 | int indOfSaveMoves = 0;
  42 | 
  43 | //for game modes
  44 | char mode = '\0';
  45 | 
  46 | //for draw(50 consecutive moves neither pawn move or any piece capture)
  47 | int consecutiveMoves = 0;
  48 | int countPreviousPieces = 32;
  49 | 
  50 | //user choice which file he want to open
  51 | char fileChoice = '\0';
  52 | 
  53 | 
  54 | //****************************************|           END OF GLOBAL VARIABLES           |***************************************
  55 | 
  56 | //Functions Header
  57 | void display(char val[8][8]);
  58 | int playerTurn(char val[8][8], bool& checkA, bool& checkB, int& countAK, int& countAr_1, int& countAr_2, int& countBk, int& countBr_1, int& countBr_2);
  59 | void checkDestination(char opposite[]);
  60 | void Movements(char board[8][8], int row, int column, int desRow, int desColumn, char opposite[]);
  61 | void Movements(char board[8][8], int row, int column, int desRow, int desColumn, char opposite[]);
  62 | 
  63 | void gotoxy(int x, int y) {
  64 | 
  65 | 	HANDLE h = GetStdHandle(STD_OUTPUT_HANDLE);
  66 | 	COORD scrn;
  67 | 
  68 | 	scrn.X = x, scrn.Y = y;
  69 | 
  70 | 	SetConsoleCursorPosition(h, scrn);
  71 | 
  72 | }
  73 | 
  74 | //for colouring
  75 | void inRed(int word) {
  76 | 	HANDLE h = GetStdHandle(STD_OUTPUT_HANDLE);
  77 | 	SetConsoleTextAttribute(h, 4);
  78 | 	if (word < 10 && word >= 0)
  79 | 		cout << "0" << word;
  80 | 	else
  81 | 	cout << word;
  82 | 	SetConsoleTextAttribute(h, 15);
  83 | }
  84 | 
  85 | //timer classic function
  86 | void classicTime(int &timer, int &hour ,int &min, int &sec) {
  87 | 	clock_t start = clock();
  88 | 	cout << "Time: " << endl;
  89 | 	while (timer >= 0 && !_kbhit())
  90 | 	{
  91 | 		if (sec == 60 && min == 60)
  92 | 		{
  93 | 			min = 0;
  94 | 			hour++;
  95 | 		}
  96 | 		if (sec == 60)
  97 | 		{
  98 | 			sec = 0;
  99 | 			min++;
 100 | 		}
 101 | 
 102 | 		cout << hour << ":";
 103 | 		cout << min << ":";
 104 | 		if (sec < 10 && sec >= 0)
 105 | 			cout << "0" << sec;
 106 | 		else
 107 | 		{
 108 | 			cout << sec;
 109 | 		}
 110 | 
 111 | 		sec++;
 112 | 		cout <<'\r';
 113 | 		Sleep(1000);
 114 | 		timer++;
 115 | 		
 116 | 	}
 117 | 	cout << '\n';
 118 | }
 119 | 
 120 | //timer rapid function
 121 | void rapidTime(int &timer)
 122 | {
 123 | 	int min, sec;
 124 | 	clock_t start = clock();
 125 | 	cout << "Time Remaining: " << endl;
 126 | 	while (timer >= 0 && !_kbhit())
 127 | 	{
 128 | 
 129 | 		min = timer / 60;
 130 | 		sec = timer % 60;
 131 | 		if (sec == 0)
 132 | 		{
 133 | 			sec = 60;
 134 | 			min--;
 135 | 		}
 136 | 		if (min < 10 && min >= 0) {
 137 | 			cout << "0" << min << ":";
 138 | 		}
 139 | 		else
 140 | 		{
 141 | 			cout << min << ":";
 142 | 		}
 143 | 		if (sec < 10 && sec >= 0)
 144 | 			cout << "0" << sec;
 145 | 		else
 146 | 		{
 147 | 			cout << sec;
 148 | 		}
 149 | 		cout << '\r';
 150 | 		Sleep(1000);
 151 | 		timer--;
 152 | 		//Check if timer 10 min expired or not
 153 | 		if ((min==0 && sec==0) || ((clock() - start) / CLOCKS_PER_SEC) >600)
 154 | 		{
 155 | 			cout << '\n';
 156 | 			cout << '\n';
 157 | 
 158 | 			cout << "GAME OVER... YOU LOST!" << endl;
 159 | 			cout << '\n';
 160 | 			system("pause");
 161 | 			exit(0);
 162 | 		}
 163 | 	}
 164 | 	cout << '\n';
 165 | }
 166 | 
 167 | //timer blitz function
 168 | void blitzTime(int & timer)
 169 | {
 170 | 	int min, sec;
 171 | 	clock_t start = clock();
 172 | 	cout << "Time Remaining: " << endl;
 173 | 	while (timer >= 0 && !_kbhit())
 174 | 	{
 175 | 
 176 | 		min = timer / 60;
 177 | 		sec = timer % 60;
 178 | 		if (sec == 0)
 179 | 		{
 180 | 			sec = 60;
 181 | 			min--;
 182 | 		}
 183 | 		cout << min << ":";
 184 | 		if (sec < 10 && sec >= 0)
 185 | 			cout << "0" << sec;
 186 | 		else
 187 | 		{
 188 | 			cout << sec;
 189 | 		}
 190 | 		cout << '\r';
 191 | 		Sleep(1000);
 192 | 		timer--;
 193 | 		//Check if 5 min timer expired or not
 194 | 		if ((min == 0 && sec == 0) || ((clock() - start) / CLOCKS_PER_SEC) > 300)
 195 | 		{
 196 | 			cout << '\n';
 197 | 			cout << '\n';
 198 | 
 199 | 			cout << "GAME OVER... YOU LOST!" << endl;
 200 | 			cout << '\n';
 201 | 			system("pause");
 202 | 			exit(0);
 203 | 		}
 204 | 	}
 205 | 	cout << '\n';
 206 | }
 207 | 
 208 | //timer lightning function
 209 | void lightningTime()
 210 | {
 211 | 	clock_t start = clock();
 212 | 
 213 | 	int timer = 15;
 214 | 	cout << "Time Remaining: " << endl;
 215 | 	while (timer >= 0 && !_kbhit())
 216 | 	{
 217 | 		inRed(timer);
 218 | 		cout <<'\r';
 219 | 		Sleep(1000);
 220 | 		timer--;
 221 | 
 222 | 		//Check if 15 sec timer expired or not
 223 | 		if (((clock() - start) / CLOCKS_PER_SEC) > 15)
 224 | 		{
 225 | 			cout << '\n';
 226 | 			cout << '\n';
 227 | 
 228 | 			//ColorIt(12);
 229 | 			cout << "GAME OVER... YOU LOST!" << endl;
 230 | 			//ColorIt(15);
 231 | 			cout << '\n';
 232 | 			system("pause");
 233 | 			exit(0);
 234 | 		}
 235 | 	}
 236 | 	cout << '\n';
 237 | }
 238 | 
 239 | //convert alphabet column into integer 
 240 | int SWITCH(char col) {
 241 | 	int column = 0;
 242 | 	switch (col) {
 243 | 	case 'a': column = 0; break;
 244 | 	case 'b': column = 1; break;
 245 | 	case 'c': column = 2; break;
 246 | 	case 'd': column = 3; break;
 247 | 	case 'e': column = 4; break;
 248 | 	case 'f': column = 5; break;
 249 | 	case 'g': column = 6; break;
 250 | 	case 'h': column = 7; break;
 251 | 	}
 252 | 	return column;
 253 | }
 254 | 
 255 | //switch for rows
 256 | int rowSwitch(char row) {
 257 | 	int r = 0;
 258 | 	switch (row) {
 259 | 	case '8': r = 0; break;
 260 | 	case '7': r = 1; break;
 261 | 	case '6': r = 2; break;
 262 | 	case '5': r = 3; break;
 263 | 	case '4': r = 4; break;
 264 | 	case '3': r = 5; break;
 265 | 	case '2': r = 6; break;
 266 | 	case '1': r = 7; break;
 267 | 	}
 268 | 	return r;
 269 | }
 270 | 
 271 | //print board of chess
 272 | void display(char val[8][8]) {
 273 | 	//system("cls");
 274 | 	cout << endl;
 275 | 	cout << "\t\t\t\t\t  ****************************************************************************\n";
 276 | 	cout << "\t\t\t\t\t  			         WELCOME TO CHESS	  				       \n";
 277 | 	cout << "\t\t\t\t\t  ****************************************************************************\n\n";
 278 | 
 279 | 	cout << "\t\t\t\t\t\t\t      a    b     c     d     e     f     g    h    " << endl;
 280 | 	cout << "\t\t\t\t\t\t\t  |-----------------------------------------------|" << endl;
 281 | 	cout << "\t\t\t\t\t\t\t  |     |     |     |     |     |     |     |     |" << endl;
 282 | 	cout << "\t\t\t\t\t\t\t 8|  " << val[0][0] << "  |  " << val[0][1] << "  |  " << val[0][2] << "  |  " << val[0][3] << "  |  " << val[0][4] << "  |  " << val[0][5] << "  |  " << val[0][6] << "  |  " << val[0][7] << "  |" << endl;
 283 | 	cout << "\t\t\t\t\t\t\t  |_____|_____|_____|_____|_____|_____|_____|_____|" << endl;
 284 | 	cout << "\t\t\t\t\t\t\t  |     |     |     |     |     |     |     |     |" << endl;
 285 | 	cout << "\t\t\t\t\t\t\t 7|  " << val[1][0] << "  |  " << val[1][1] << "  |  " << val[1][2] << "  |  " << val[1][3] << "  |  " << val[1][4] << "  |  " << val[1][5] << "  |  " << val[1][6] << "  |  " << val[1][7] << "  |" << endl;
 286 | 	cout << "\t\t\t\t\t\t\t  |_____|_____|_____|_____|_____|_____|_____|_____|" << endl;
 287 | 	cout << "\t\t\t\t\t\t\t  |     |     |     |     |     |     |     |     |" << endl;
 288 | 	cout << "\t\t\t\t\t\t\t 6|  " << val[2][0] << "  |  " << val[2][1] << "  |  " << val[2][2] << "  |  " << val[2][3] << "  |  " << val[2][4] << "  |  " << val[2][5] << "  |  " << val[2][6] << "  |  " << val[2][7] << "  |" << endl;
 289 | 	cout << "\t\t\t\t\t\t\t  |_____|_____|_____|_____|_____|_____|_____|_____|" << endl;
 290 | 	cout << "\t\t\t\t\t\t\t  |     |     |     |     |     |     |     |     |" << endl;
 291 | 	cout << "\t\t\t\t\t\t\t 5|  " << val[3][0] << "  |  " << val[3][1] << "  |  " << val[3][2] << "  |  " << val[3][3] << "  |  " << val[3][4] << "  |  " << val[3][5] << "  |  " << val[3][6] << "  |  " << val[3][7] << "  |" << endl;
 292 | 	cout << "\t\t\t\t\t\t\t  |_____|_____|_____|_____|_____|_____|_____|_____|" << endl;
 293 | 	cout << "\t\t\t\t\t\t\t  |     |     |     |     |     |     |     |     |" << endl;
 294 | 	cout << "\t\t\t\t\t\t\t 4|  " << val[4][0] << "  |  " << val[4][1] << "  |  " << val[4][2] << "  |  " << val[4][3] << "  |  " << val[4][4] << "  |  " << val[4][5] << "  |  " << val[4][6] << "  |  " << val[4][7] << "  |" << endl;
 295 | 	cout << "\t\t\t\t\t\t\t  |_____|_____|_____|_____|_____|_____|_____|_____|" << endl;
 296 | 	cout << "\t\t\t\t\t\t\t  |     |     |     |     |     |     |     |     |" << endl;
 297 | 	cout << "\t\t\t\t\t\t\t 3|  " << val[5][0] << "  |  " << val[5][1] << "  |  " << val[5][2] << "  |  " << val[5][3] << "  |  " << val[5][4] << "  |  " << val[5][5] << "  |  " << val[5][6] << "  |  " << val[5][7] << "  |" << endl;
 298 | 	cout << "\t\t\t\t\t\t\t  |_____|_____|_____|_____|_____|_____|_____|_____|" << endl;
 299 | 	cout << "\t\t\t\t\t\t\t  |     |     |     |     |     |     |     |     |" << endl;
 300 | 	cout << "\t\t\t\t\t\t\t 2|  " << val[6][0] << "  |  " << val[6][1] << "  |  " << val[6][2] << "  |  " << val[6][3] << "  |  " << val[6][4] << "  |  " << val[6][5] << "  |  " << val[6][6] << "  |  " << val[6][7] << "  |" << endl;
 301 | 	cout << "\t\t\t\t\t\t\t  |_____|_____|_____|_____|_____|_____|_____|_____|" << endl;
 302 | 	cout << "\t\t\t\t\t\t\t  |     |     |     |     |     |     |     |     |" << endl;
 303 | 	cout << "\t\t\t\t\t\t\t 1|  " << val[7][0] << "  |  " << val[7][1] << "  |  " << val[7][2] << "  |  " << val[7][3] << "  |  " << val[7][4] << "  |  " << val[7][5] << "  |  " << val[7][6] << "  |  " << val[7][7] << "  |" << endl;
 304 | 	cout << "\t\t\t\t\t\t\t  |-----------------------------------------------|" << endl;
 305 | 	
 306 | }//End interface function
 307 | 
 308 | //to display replay
 309 | void replaymove(char chess[][8], int currentrow, int currentcol, int rowtogo, int coltogo) 
 310 | {
 311 | 	checkDestination(opposite);
 312 | 	if (chess[currentrow][currentcol] != 'P' || chess[currentrow][currentcol] != 'p') {
 313 | 		chess[rowtogo][coltogo] = chess[currentrow][currentcol];
 314 | 		chess[currentrow][currentcol] = ' ';
 315 | 	}
 316 | 	else
 317 | 	{
 318 | 		Movements(chess, currentrow, currentcol, rowtogo, coltogo, opposite);
 319 | 	}
 320 | }
 321 | 
 322 | //store all valid turns(FOR REPLAY)
 323 | void replayStore(int row, char col, int desRow, char desCol) {
 324 | 	char srcRow = 8 - row + 48;
 325 | 	char destinationRow = 8 - desRow + 48;
 326 | 
 327 | 	saveMoves[indOfSaveMoves] = col;
 328 | 	indOfSaveMoves++;
 329 | 	saveMoves[indOfSaveMoves] = srcRow;
 330 | 	indOfSaveMoves++;
 331 | 	saveMoves[indOfSaveMoves] = desCol;
 332 | 	indOfSaveMoves++;
 333 | 	saveMoves[indOfSaveMoves] = destinationRow;
 334 | 	indOfSaveMoves++;
 335 | 	saveMoves[indOfSaveMoves] = '\n';
 336 | 	indOfSaveMoves++;
 337 | 
 338 | }
 339 | 
 340 | 
 341 | //contains opponent pieces
 342 | void checkDestination(char opposite[]) {
 343 | 	if (turn == 'A') {
 344 | 		opposite[0] = 'p', opposite[1] = 'r', opposite[2] = 'n', opposite[3] = 'b', opposite[4] = 'q', opposite[5] = 'k';
 345 | 	}
 346 | 	else if (turn == 'B') {
 347 | 		opposite[0] = 'P', opposite[1] = 'R', opposite[2] = 'N', opposite[3] = 'B', opposite[4] = 'Q', opposite[5] = 'K';
 348 | 	}
 349 | }
 350 | 
 351 | //find king position
 352 | void kingPosition(char val[8][8], int& indi, int& indj) {
 353 | 	if (turn == 'A') {
 354 | 		//find king present coordinates
 355 | 		bool cond = true;
 356 | 		indi = 9, indj = 9;
 357 | 		for (int i = 0; i < 8 && cond == true; i++) {
 358 | 			for (int j = 0; j < 8; j++) {
 359 | 				if (val[i][j] == 'K') {
 360 | 					indi = i;
 361 | 					indj = j;
 362 | 					cond = false;
 363 | 					break;
 364 | 				}
 365 | 			}
 366 | 		}
 367 | 	}
 368 | 
 369 | 	else if (turn == 'B')
 370 | 	{
 371 | 		//find king present coordinates
 372 | 		bool cond = true;
 373 | 		indi = 9, indj = 9;
 374 | 		for (int i = 0; i < 8 && cond == true; i++) {
 375 | 			for (int j = 0; j < 8; j++) {
 376 | 				if (val[i][j] == 'k') {
 377 | 					indi = i;
 378 | 					indj = j;
 379 | 					cond = false;
 380 | 					break;
 381 | 				}
 382 | 			}
 383 | 		}
 384 | 	}
 385 | }
 386 | 
 387 | //Valid MOVES
 388 | bool pawnForWhite(char val[8][8], int row, int column, int desRow, int desColumn, char opposite[])
 389 | {
 390 | 	char ch = 32;
 391 | 	//for empassent condition
 392 | 	if (val[desRow][desColumn] == ch && prevCoordinate[4] == 1 && prevCoordinate[6] == row && desRow == row - 1 && (desColumn == column + 1 || desColumn == column - 1)) {
 393 | 		val[desRow][desColumn] = val[row][column];
 394 | 		val[row][column] = ch;
 395 | 		val[prevCoordinate[6]][prevCoordinate[7]] = ch;
 396 | 		return true;
 397 | 	}
 398 | 	//killing the opponent piece
 399 | 	else if (val[desRow][desColumn] == opposite[0] || val[desRow][desColumn] == opposite[1] || val[desRow][desColumn] == opposite[2] || val[desRow][desColumn] == opposite[3] || val[desRow][desColumn] == opposite[4] || val[desRow][desColumn] == opposite[5])
 400 | 	{
 401 | 		if (desRow == row - 1 && desColumn == column + 1)
 402 | 		{
 403 | 			val[desRow][desColumn] = val[row][column];
 404 | 			val[row][column] = ch;
 405 | 
 406 | 			//pawn promotion
 407 | 			if (desRow == 0)
 408 | 			{
 409 | 				cout << "R\tN\tB\tQ\n";
 410 | 				cin >> val[row][column];
 411 | 				while (val[row][column] != 'R' && val[row][column] != 'N' && val[row][column] != 'B' && val[row][column] != 'Q') {
 412 | 					cout << "R\tN\tB\tQ\n";
 413 | 					cin >> val[row][column];
 414 | 				}
 415 | 				val[desRow][desColumn] = val[row][column];
 416 | 				return true;
 417 | 			}
 418 | 			return true;
 419 | 		}
 420 | 		else if (desRow == row - 1 && desColumn == column - 1)
 421 | 		{
 422 | 			val[desRow][desColumn] = val[row][column];
 423 | 			val[row][column] = ch;
 424 | 
 425 | 			//pawn promotion
 426 | 			if (desRow == 0)
 427 | 			{
 428 | 				cout << "R\tN\tB\tQ\n";
 429 | 				cin >> val[row][column];
 430 | 				while (val[row][column] != 'R' && val[row][column] != 'N' && val[row][column] != 'B' && val[row][column] != 'Q') {
 431 | 					cout << "R\tN\tB\tQ\n";
 432 | 					cin >> val[row][column];
 433 | 				}
 434 | 				val[desRow][desColumn] = val[row][column];
 435 | 				return true;
 436 | 			}
 437 | 			return true;
 438 | 		}
 439 | 	}
 440 | 
 441 | 	//first move of pawn i.e it can move one step or two steps
 442 | 	else if (row == 6)
 443 | 	{
 444 | 		if ((desRow == row - 1 || desRow == row - 2) && column == desColumn && val[desRow][desColumn] == ch) {
 445 | 			if ((desRow == row - 2 && val[row - 1][desColumn] == ch) || desRow == row - 1) {
 446 | 				val[desRow][desColumn] = val[row][column];
 447 | 				val[row][column] = ch;
 448 | 				return true;
 449 | 			}
 450 | 		}
 451 | 	}
 452 | 
 453 | 	else if (desRow == row - 1 && column == desColumn)
 454 | 	{
 455 | 		if (desRow == 0)
 456 | 		{
 457 | 
 458 | 			//pawn promotion
 459 | 			cout << "R\tN\tB\tQ\n";
 460 | 			cin >> val[row][column];
 461 | 			while (val[row][column] != 'R' && val[row][column] != 'N' && val[row][column] != 'B' && val[row][column] != 'Q') {
 462 | 				cout << "R\tN\tB\tQ\n";
 463 | 				cin >> val[row][column];
 464 | 			}
 465 | 			val[desRow][desColumn] = val[row][column];
 466 | 			return true;
 467 | 		}
 468 | 		else if (val[desRow][desColumn] == ch)
 469 | 		{
 470 | 			val[desRow][desColumn] = val[row][column];
 471 | 			val[row][column] = ch;
 472 | 			return true;
 473 | 		}
 474 | 	}
 475 | 	return false;
 476 | }//PAWN FOR PLAYER WHITE END
 477 | 
 478 | bool rookForWhite(char val[8][8], int row, int column, int desRow, int desColumn, char opposite[])
 479 | {
 480 | 	checkDestination(opposite);
 481 | 	char ch = ' ';
 482 | 	int count = 0;
 483 | 	if (desColumn == column)
 484 | 	{
 485 | 		count = row;
 486 | 		if (desRow > row)
 487 | 		{																		//if destination row is greater than source row
 488 | 			for (int i = row; i <= desRow; i++)
 489 | 			{
 490 | 				if (val[i][desColumn] == ch)
 491 | 					count++;
 492 | 			}
 493 | 			if (val[desRow][desColumn] != ch && (val[desRow][desColumn] == opposite[0] || val[desRow][desColumn] == opposite[1] || val[desRow][desColumn] == opposite[2] || val[desRow][desColumn] == opposite[3] || val[desRow][desColumn] == opposite[4] || val[desRow][desColumn] == opposite[5]))
 494 | 				count++;
 495 | 		}
 496 | 		else if (desRow < row)													//if destination row is less than source row
 497 | 		{
 498 | 			for (int i = row; i >= desRow; i--)
 499 | 			{
 500 | 				if (val[i][column] == ch) {
 501 | 					count--;
 502 | 				}
 503 | 			}
 504 | 			if (val[desRow][desColumn] != ch && (val[desRow][desColumn] == opposite[0] || val[desRow][desColumn] == opposite[1] || val[desRow][desColumn] == opposite[2] || val[desRow][desColumn] == opposite[3] || val[desRow][desColumn] == opposite[4] || val[desRow][desColumn] == opposite[5]))
 505 | 				count--;
 506 | 		}
 507 | 
 508 | 		if (count == desRow)
 509 | 		{
 510 | 			return true;
 511 | 		}
 512 | 	}//FOR SAME COLUMN END
 513 | 
 514 | 	else if (desRow == row)
 515 | 	{
 516 | 		count = column;
 517 | 		if (desColumn > column)
 518 | 		{
 519 | 			for (int i = column; i <= desColumn; i++)
 520 | 			{
 521 | 				if (val[row][i] == ch)
 522 | 					count++;
 523 | 			}
 524 | 			if (val[desRow][desColumn] != ch && (val[desRow][desColumn] == opposite[0] || val[desRow][desColumn] == opposite[1] || val[desRow][desColumn] == opposite[2] || val[desRow][desColumn] == opposite[3] || val[desRow][desColumn] == opposite[4] || val[desRow][desColumn] == opposite[5]))
 525 | 				count++;
 526 | 		}
 527 | 		else if (column > desColumn)
 528 | 		{
 529 | 			for (int i = column; i >= desColumn; i--)
 530 | 			{
 531 | 				if (val[row][i] == ch)
 532 | 					count--;
 533 | 			}
 534 | 			if (val[desRow][desColumn] != ch && (val[desRow][desColumn] == opposite[0] || val[desRow][desColumn] == opposite[1] || val[desRow][desColumn] == opposite[2] || val[desRow][desColumn] == opposite[3] || val[desRow][desColumn] == opposite[4] || val[desRow][desColumn] == opposite[5]))
 535 | 				count--;
 536 | 		}
 537 | 
 538 | 		if (count == desColumn)
 539 | 		{
 540 | 			return true;
 541 | 		}
 542 | 	}//FOR SAME ROW END
 543 | 	return false;
 544 | }//end of rookForWhite 
 545 | 
 546 | bool knightForWhite(char val[8][8], int row, int column, int desRow, int desColumn, char opposite[]) {
 547 | 	char ch = ' ';
 548 | 	if (desRow == row + 1) {
 549 | 		if (desColumn == column + 2 && (val[desRow][desColumn] == ch || val[desRow][desColumn] == opposite[0] || val[desRow][desColumn] == opposite[1] || val[desRow][desColumn] == opposite[2] || val[desRow][desColumn] == opposite[3] || val[desRow][desColumn] == opposite[4] || val[desRow][desColumn] == opposite[5])) {
 550 | 			return true;
 551 | 		}
 552 | 		else if (desColumn == column - 2 && (val[desRow][desColumn] == ch || val[desRow][desColumn] == opposite[0] || val[desRow][desColumn] == opposite[1] || val[desRow][desColumn] == opposite[2] || val[desRow][desColumn] == opposite[3] || val[desRow][desColumn] == opposite[4] || val[desRow][desColumn] == opposite[5])) {
 553 | 			return true;
 554 | 		}
 555 | 	}
 556 | 	else if (desRow == row - 1) {
 557 | 		if (desColumn == column + 2 && (val[desRow][desColumn] == ch || val[desRow][desColumn] == opposite[0] || val[desRow][desColumn] == opposite[1] || val[desRow][desColumn] == opposite[2] || val[desRow][desColumn] == opposite[3] || val[desRow][desColumn] == opposite[4] || val[desRow][desColumn] == opposite[5])) {
 558 | 			return true;
 559 | 		}
 560 | 		else if (desColumn == column - 2 && (val[desRow][desColumn] == ch || val[desRow][desColumn] == opposite[0] || val[desRow][desColumn] == opposite[1] || val[desRow][desColumn] == opposite[2] || val[desRow][desColumn] == opposite[3] || val[desRow][desColumn] == opposite[4] || val[desRow][desColumn] == opposite[5])) {
 561 | 			val[desRow][desColumn] = val[row][column];
 562 | 			val[row][column] = ch;
 563 | 			return true;
 564 | 		}
 565 | 	}
 566 | 	else if (desColumn == column + 1) {
 567 | 		if (desRow == row + 2 && (val[desRow][desColumn] == ch || val[desRow][desColumn] == opposite[0] || val[desRow][desColumn] == opposite[1] || val[desRow][desColumn] == opposite[2] || val[desRow][desColumn] == opposite[3] || val[desRow][desColumn] == opposite[4] || val[desRow][desColumn] == opposite[5])) {
 568 | 			return true;
 569 | 		}
 570 | 		else if (desRow == row - 2 && (val[desRow][desColumn] == ch || val[desRow][desColumn] == opposite[0] || val[desRow][desColumn] == opposite[1] || val[desRow][desColumn] == opposite[2] || val[desRow][desColumn] == opposite[3] || val[desRow][desColumn] == opposite[4] || val[desRow][desColumn] == opposite[5])) {
 571 | 			return true;
 572 | 		}
 573 | 	}
 574 | 	else if (desColumn == column - 1) {
 575 | 		if (desRow == row + 2 && (val[desRow][desColumn] == ch || val[desRow][desColumn] == opposite[0] || val[desRow][desColumn] == opposite[1] || val[desRow][desColumn] == opposite[2] || val[desRow][desColumn] == opposite[3] || val[desRow][desColumn] == opposite[4] || val[desRow][desColumn] == opposite[5])) {
 576 | 			return true;
 577 | 		}
 578 | 		else if (desRow == row - 2 && (val[desRow][desColumn] == ch || val[desRow][desColumn] == opposite[0] || val[desRow][desColumn] == opposite[1] || val[desRow][desColumn] == opposite[2] || val[desRow][desColumn] == opposite[3] || val[desRow][desColumn] == opposite[4] || val[desRow][desColumn] == opposite[5])) {
 579 | 			return true;
 580 | 		}
 581 | 	}
 582 | 	return false;
 583 | }  // end of knightForWhite
 584 | 
 585 | bool bishopForWhite(char val[8][8], int row, int column, int desRow, int desColumn, char opposite[]) {
 586 | 	char ch = ' ';
 587 | 	int count = 0;
 588 | 	bool found = true;
 589 | 	if (desRow > row && desColumn > column) {								//Forward down diagonal
 590 | 		for (int i = row + 1, j = column + 1; i < 8 && j < 8; i++, j++) {
 591 | 			if (desRow == i && desColumn == j) {
 592 | 				found = false;
 593 | 				break;
 594 | 			}
 595 | 			else if (val[i][j] == ch) {
 596 | 				count++;
 597 | 			}
 598 | 		}
 599 | 	}
 600 | 	else if (desRow > row&& desColumn < column) {							//Backward down diagonal
 601 | 		for (int i = row, j = column; i < 8 && j >= 0; i++, j--) {
 602 | 			if (desRow == i && desColumn == j) {
 603 | 				found = false;
 604 | 				break;
 605 | 			}
 606 | 			else if (val[i][j] == ch) {
 607 | 				count++;
 608 | 			}
 609 | 		}
 610 | 	}
 611 | 	else if (desRow < row && desColumn > column) {							//Forward up diagonal
 612 | 		for (int i = row, j = column; i >= 0 && j < 8; i--, j++) {
 613 | 			if (desRow == i && desColumn == j) {
 614 | 				found = false;
 615 | 				break;
 616 | 			}
 617 | 			else if (val[i][j] == ch) {
 618 | 				count++;
 619 | 			}
 620 | 		}
 621 | 	}
 622 | 	else if (desRow < row && desColumn < column) {							//Backward up diagonal
 623 | 		for (int i = row, j = column; i >= 0 && j >= 0; i--, j--) {
 624 | 			if (desRow == i && desColumn == j) {
 625 | 				found = false;
 626 | 				break;
 627 | 			}
 628 | 			else if (val[i][j] == ch) {
 629 | 				count++;
 630 | 			}
 631 | 		}
 632 | 	}
 633 | 	if (val[desRow][desColumn] == ch || val[desRow][desColumn] == opposite[0] || val[desRow][desColumn] == opposite[1] || val[desRow][desColumn] == opposite[2] || val[desRow][desColumn] == opposite[3] || val[desRow][desColumn] == opposite[4] || val[desRow][desColumn] == opposite[5]) {
 634 | 		count++;
 635 | 	}
 636 | 	int dif = desRow - row;
 637 | 	if (dif < 0)
 638 | 		dif = -1 * dif;
 639 | 	if (found == false && count == dif) {
 640 | 		return true;
 641 | 	}
 642 | 	return false;
 643 | }
 644 | 
 645 | bool queenForWhite(char val[8][8], int row, int column, int desRow, int desColumn, char opposite[]) {
 646 | 	bool rook = rookForWhite(val, row, column, desRow, desColumn, opposite);
 647 | 	if (rook == false) {
 648 | 		bool bishop = bishopForWhite(val, row, column, desRow, desColumn, opposite);
 649 | 		if (bishop == false) {
 650 | 			return false;
 651 | 		}
 652 | 		else {
 653 | 			return true;
 654 | 		}
 655 | 	}
 656 | 		return rook;
 657 | }
 658 | 
 659 | bool kingForWhite(char val[8][8], int row, int column, int desRow, int desColumn, char opposite[]) {
 660 | 	char ch = ' ';
 661 | 	if (desColumn == column && (desRow == row + 1 || desRow == row - 1)) {
 662 | 		if (val[desRow][desColumn] == ch || val[desRow][desColumn] == opposite[0] || val[desRow][desColumn] == opposite[1] || val[desRow][desColumn] == opposite[2] || val[desRow][desColumn] == opposite[3] || val[desRow][desColumn] == opposite[4] || val[desRow][desColumn] == opposite[5]) {
 663 | 			return true;
 664 | 		}
 665 | 	}
 666 | 	else if (desRow == row && (desColumn == column + 1 || desColumn == column - 1)) {
 667 | 		if (val[desRow][desColumn] == ch || val[desRow][desColumn] == opposite[0] || val[desRow][desColumn] == opposite[1] || val[desRow][desColumn] == opposite[2] || val[desRow][desColumn] == opposite[3] || val[desRow][desColumn] == opposite[4] || val[desRow][desColumn] == opposite[5]) {
 668 | 			return true;
 669 | 		}
 670 | 	}
 671 | 	else if (desRow == row + 1 && (desColumn == column + 1 || desColumn == column - 1)) {
 672 | 		if (val[desRow][desColumn] == ch || val[desRow][desColumn] == opposite[0] || val[desRow][desColumn] == opposite[1] || val[desRow][desColumn] == opposite[2] || val[desRow][desColumn] == opposite[3] || val[desRow][desColumn] == opposite[4] || val[desRow][desColumn] == opposite[5]) {
 673 | 			return true;
 674 | 		}
 675 | 	}
 676 | 	else if (desRow == row - 1 && (desColumn == column + 1 || desColumn == column - 1)) {
 677 | 		if (val[desRow][desColumn] == ch || val[desRow][desColumn] == opposite[0] || val[desRow][desColumn] == opposite[1] || val[desRow][desColumn] == opposite[2] || val[desRow][desColumn] == opposite[3] || val[desRow][desColumn] == opposite[4] || val[desRow][desColumn] == opposite[5]) {
 678 | 			return true;
 679 | 		}
 680 | 	}
 681 | 	return false;
 682 | }
 683 | 
 684 | bool pawnForBlack(char val[8][8], int row, int column, int desRow, int desColumn, char opposite[]) {
 685 | 	char ch = 32;
 686 | 	if (val[desRow][desColumn] == ch && prevCoordinate[0] == 6 && prevCoordinate[2] == row && desRow == row + 1 && (desColumn == column + 1 || desColumn == column - 1)) {
 687 | 		val[desRow][desColumn] = val[row][column];
 688 | 		val[row][column] = ch;
 689 | 		val[prevCoordinate[2]][prevCoordinate[3]] = ch;
 690 | 		return true;
 691 | 	}
 692 | 	else if (val[desRow][desColumn] == opposite[0] || val[desRow][desColumn] == opposite[1] || val[desRow][desColumn] == opposite[2] || val[desRow][desColumn] == opposite[3] || val[desRow][desColumn] == opposite[4] || val[desRow][desColumn] == opposite[5])
 693 | 	{
 694 | 		if (desRow == row + 1 && desColumn == column + 1)
 695 | 		{
 696 | 			val[desRow][desColumn] = val[row][column];
 697 | 			val[row][column] = ch;
 698 | 			if (desRow == 7)
 699 | 			{
 700 | 				cout << "r\tn\tb\tq\n";
 701 | 				cin >> val[row][column];
 702 | 				while (val[row][column] != 'r' && val[row][column] != 'n' && val[row][column] != 'b' && val[row][column] != 'q') {
 703 | 					cout << "r\tn\tb\tq\n";
 704 | 					cin >> val[row][column];
 705 | 				}
 706 | 				val[desRow][desColumn] = val[row][column];
 707 | 				return true;
 708 | 			}
 709 | 			return true;
 710 | 		}
 711 | 		else if (desRow == row + 1 && desColumn == column - 1)
 712 | 		{
 713 | 			val[desRow][desColumn] = val[row][column];
 714 | 			val[row][column] = ch;
 715 | 			if (desRow == 7)
 716 | 			{
 717 | 				cout << "r\tn\tb\tq\n";
 718 | 				cin >> val[row][column];
 719 | 				while (val[row][column] != 'r' && val[row][column] != 'n' && val[row][column] != 'b' && val[row][column] != 'q') {
 720 | 					cout << "r\tn\tb\tq\n";
 721 | 					cin >> val[row][column];
 722 | 				}
 723 | 				val[desRow][desColumn] = val[row][column];
 724 | 				return true;
 725 | 			}
 726 | 			return true;
 727 | 		}
 728 | 	}
 729 | 
 730 | 	else if (row == 1)
 731 | 	{
 732 | 		if ((desRow == row + 1 || desRow == row + 2) && column == desColumn && val[desRow][desColumn] == ch) {
 733 | 			if (desRow == row + 1 || (desRow == row + 2 && val[row + 1][desColumn] == ch)) {
 734 | 				val[desRow][desColumn] = val[row][column];
 735 | 				val[row][column] = ch;
 736 | 				return true;
 737 | 			}
 738 | 		}
 739 | 	}
 740 | 
 741 | 	else if (desRow == row + 1 && column == desColumn)
 742 | 	{
 743 | 		if (desRow == 7)
 744 | 		{
 745 | 			cout << "r\tn\tb\tq\n";
 746 | 			cin >> val[row][column];
 747 | 			while (val[row][column] != 'r' && val[row][column] != 'n' && val[row][column] != 'b' && val[row][column] != 'q') {
 748 | 				cout << "r\tn\tb\tq\n";
 749 | 				cin >> val[row][column];
 750 | 			}
 751 | 			val[desRow][desColumn] = val[row][column];
 752 | 			return true;
 753 | 		}
 754 | 		else if (val[desRow][desColumn] == ch)
 755 | 		{
 756 | 			val[desRow][desColumn] = val[row][column];
 757 | 			val[row][column] = ch;
 758 | 			return true;
 759 | 		}
 760 | 	}
 761 | 	return false;
 762 | }//pawn for black end
 763 | 
 764 | void Movements(char board[8][8], int row, int column, int desRow, int desColumn, char opposite[])
 765 | {
 766 | 	checkDestination(opposite);
 767 | 	if (board[row][column] == 'P')
 768 | 		pawnForWhite(board, row, column, desRow, desColumn, opposite);
 769 | 	else if (board[row][column] == 'p')
 770 | 		pawnForBlack(board, row, column, desRow, desColumn, opposite);
 771 | 	else if (board[row][column] == 'R' || board[row][column] == 'r') {
 772 | 		checkDestination(opposite);
 773 | 		bool found = rookForWhite(board, row, column, desRow, desColumn, opposite);
 774 | 		if (found == true) {
 775 | 			board[desRow][desColumn] = board[row][column];
 776 | 			board[row][column] = ' ';
 777 | 		}
 778 | 	}
 779 | 	else if (board[row][column] == 'N' || board[row][column] == 'n') {
 780 | 		bool found = knightForWhite(board, row, column, desRow, desColumn, opposite);
 781 | 		if (found == true) {
 782 | 			board[desRow][desColumn] = board[row][column];
 783 | 			board[row][column] = ' ';
 784 | 		}
 785 | 	}
 786 | 	else if (board[row][column] == 'B' || board[row][column] == 'b') {
 787 | 		bool found = bishopForWhite(board, row, column, desRow, desColumn, opposite);
 788 | 		if (found == true) {
 789 | 			board[desRow][desColumn] = board[row][column];
 790 | 			board[row][column] = ' ';
 791 | 		}
 792 | 	}
 793 | 	else if (board[row][column] == 'Q' || board[row][column] == 'q') {
 794 | 		bool found = queenForWhite(board, row, column, desRow, desColumn, opposite);
 795 | 		if (found == true) {
 796 | 			board[desRow][desColumn] = board[row][column];
 797 | 			board[row][column] = ' ';
 798 | 		}
 799 | 	}
 800 | 	else if (board[row][column] == 'K' || board[row][column] == 'k') {
 801 | 		bool found = kingForWhite(board, row, column, desRow, desColumn, opposite);
 802 | 		if (found == true) {
 803 | 			board[desRow][desColumn] = board[row][column];
 804 | 			board[row][column] = ' ';
 805 | 		}
 806 | 	}
 807 | }
 808 | 
 809 | 
 810 | //CHECKS 
 811 | bool pawnCheckforWhite(char val[8][8], int row, int column, char opposite[]) {
 812 | 	if (val[row - 1][column + 1] == opposite[0] || val[row - 1][column - 1] == opposite[0]) {
 813 | 		storeCheckPieceInd[0] = row - 1;
 814 | 		if (val[row - 1][column + 1] == opposite[0])
 815 | 			storeCheckPieceInd[1] = column + 1;
 816 | 		else if (val[row - 1][column - 1] == opposite[0])
 817 | 			storeCheckPieceInd[1] = column - 1;
 818 | 		return true;
 819 | 	}
 820 | 	return false;
 821 | }
 822 | 
 823 | bool pawnCheckforBlack(char val[8][8], int row, int column, char opposite[]) {
 824 | 	if (val[row + 1][column + 1] == opposite[0] || val[row + 1][column - 1] == opposite[0]) {
 825 | 		storeCheckPieceInd[0] = row + 1;
 826 | 		if (val[row + 1][column + 1] == opposite[0])
 827 | 			storeCheckPieceInd[1] = column + 1;
 828 | 		else if (val[row + 1][column - 1] == opposite[0])
 829 | 			storeCheckPieceInd[1] = column - 1;
 830 | 		return true;
 831 | 	}
 832 | 	return false;
 833 | }
 834 | 
 835 | bool rookCheck(char val[8][8], int row, int column, char opposite[]) {
 836 | 	int count = 1, i = 0;
 837 | 	for (i = row; i < 7 && val[i][column] != opposite[1]; i++) {						//same column upward
 838 | 		if (val[i][column] == ' ')
 839 | 			count++;
 840 | 	}
 841 | 	int dif = i - row;
 842 | 	if (count == dif && val[i][column] == opposite[1]) {
 843 | 		return true;
 844 | 	}
 845 | 	count = 1, i = 0;
 846 | 	for (i = row; i > 0 && val[i][column] != opposite[1]; i--) {						//same column downward
 847 | 		if (val[i][column] == ' ')
 848 | 			count++;
 849 | 	}
 850 | 	dif = row - i;
 851 | 	if (count == dif && val[i][column] == opposite[1]) {
 852 | 		return true;
 853 | 	}
 854 | 
 855 | 	count = 1, i = 0;
 856 | 	for (i = column; i < 7 && val[row][i] != opposite[1]; i++) {						//same row rightward
 857 | 		if (val[row][i] == ' ')
 858 | 			count++;
 859 | 	}
 860 | 	dif = i - column;
 861 | 	if (count == dif && val[row][i] == opposite[1]) {
 862 | 		return true;
 863 | 	}
 864 | 	count = 1, i = 0;
 865 | 	for (i = column; i > 0 && val[row][i] != opposite[1]; i--) {						//same row leftward
 866 | 		if (val[row][i] == ' ')
 867 | 			count++;
 868 | 	}
 869 | 	dif = column - i;
 870 | 	if (count == dif && val[row][i] == opposite[1]) {
 871 | 		return true;
 872 | 	}
 873 | 	return false;
 874 | }
 875 | 
 876 | bool knightCheck(char val[8][8], int row, int column, char opposite[]) {
 877 | 	if (val[row + 1][column + 2] == opposite[2] || val[row + 1][column - 2] == opposite[2] || val[row - 1][column + 2] == opposite[2] || val[row - 1][column - 2] == opposite[2] || val[row + 2][column + 1] == opposite[2] || val[row + 2][column - 1] == opposite[2] || val[row - 2][column + 1] == opposite[2] || val[row - 2][column - 1] == opposite[2])
 878 | 	{
 879 | 		if (val[row + 1][column + 2] == opposite[2]) {
 880 | 			storeCheckPieceInd[0] = row + 1;
 881 | 			storeCheckPieceInd[1] = column + 2;
 882 | 		}
 883 | 		else if (val[row + 1][column - 2] == opposite[2]) {
 884 | 			storeCheckPieceInd[0] = row + 1;
 885 | 			storeCheckPieceInd[1] = column - 2;
 886 | 		}
 887 | 		else if (val[row - 1][column + 2] == opposite[2]) {
 888 | 			storeCheckPieceInd[0] = row - 1;
 889 | 			storeCheckPieceInd[1] = column + 2;
 890 | 		}
 891 | 		else if (val[row - 1][column - 2] == opposite[2]) {
 892 | 			storeCheckPieceInd[0] = row - 1;
 893 | 			storeCheckPieceInd[1] = column - 2;
 894 | 		}
 895 | 		else if (val[row + 2][column + 1] == opposite[2]) {
 896 | 			storeCheckPieceInd[0] = row + 2;
 897 | 			storeCheckPieceInd[1] = column + 1;
 898 | 		}
 899 | 		else if (val[row + 2][column - 1] == opposite[2]) {
 900 | 			storeCheckPieceInd[0] = row + 2;
 901 | 			storeCheckPieceInd[1] = column - 1;
 902 | 		}
 903 | 		else if (val[row - 2][column - 1] == opposite[2]) {
 904 | 			storeCheckPieceInd[0] = row - 2;
 905 | 			storeCheckPieceInd[1] = column - 1;
 906 | 		}
 907 | 		else if (val[row - 2][column + 1] == opposite[2]) {
 908 | 			storeCheckPieceInd[0] = row - 2;
 909 | 			storeCheckPieceInd[1] = column + 1;
 910 | 		}
 911 | 		return true;
 912 | 	}
 913 | 	return false;
 914 | }
 915 | 
 916 | bool bishopCheck(char val[8][8], int row, int column, char opposite[]) {
 917 | 	int count = 1, i = 0, j = 0;
 918 | 	for (i = row, j = column; val[i][j] != opposite[3] && i > 0 && j < 7; i--, j++) {			//forward upward diagonal
 919 | 		if (val[i][j] == ' ')
 920 | 			count++;
 921 | 	}
 922 | 	int dif = row - i;
 923 | 	if (count == dif && val[i][j] == opposite[3]) {
 924 | 		return true;
 925 | 	}//end up forward diagonal
 926 | 
 927 | 	count = 1, i = 0, j = 0;
 928 | 	for (i = row, j = column; val[i][j] != opposite[3] && i < 7 && j < 7; i++, j++) {			//forward downward diagonal
 929 | 		if (val[i][j] == ' ')
 930 | 			count++;
 931 | 	}
 932 | 	dif = i - row;
 933 | 	if (count == dif && val[i][j] == opposite[3]) {
 934 | 		return true;
 935 | 	}//end down forward diagonal 
 936 | 
 937 | 	count = 1, i = 0, j = 0;
 938 | 	for (i = row, j = column; val[i][j] != opposite[3] && i > 0 && j > 0; i--, j--) {				//backward up diagonal
 939 | 		if (val[i][j] == ' ')
 940 | 			count++;
 941 | 	}
 942 | 	dif = row - i;
 943 | 	if (count == dif && val[i][j] == opposite[3]) {
 944 | 		return true;
 945 | 	}//end up backward diagonal
 946 | 
 947 | 	count = 1, i = 0, j = 0;
 948 | 	for (i = row, j = column; val[i][j] != opposite[3] && i < 7 && j > 0; i++, j--) {				//downward backward diagonal
 949 | 		if (val[i][j] == ' ')
 950 | 			count++;
 951 | 	}
 952 | 	dif = i - row;
 953 | 	if (count == dif && val[i][j] == opposite[3]) {
 954 | 		return true;
 955 | 	}//end down backward diagonal
 956 | 	return false;
 957 | }
 958 | 
 959 | bool queenCheck(char val[8][8], int row, int column, char opposite[]) {
 960 | 	int count = 1, i = 0, j = 0;
 961 | 	for (i = row; i < 7 && val[i][column] != opposite[4]; i++) {						//same column upward
 962 | 		if (val[i][column] == ' ')
 963 | 			count++;
 964 | 	}
 965 | 	int dif = i - row;
 966 | 	if (count == dif && val[i][column] == opposite[4]) {
 967 | 		return true;
 968 | 	}
 969 | 	count = 1, i = 0;
 970 | 	for (i = row; i > 0 && val[i][column] != opposite[4]; i--) {						//same column downward
 971 | 		if (val[i][column] == ' ')
 972 | 			count++;
 973 | 	}
 974 | 	dif = row - i;
 975 | 	if (count == dif && val[i][column] == opposite[4]) {
 976 | 		return true;
 977 | 	}
 978 | 
 979 | 	count = 1, i = 0;
 980 | 	for (i = column; i < 7 && val[row][i] != opposite[4]; i++) {						//same row rightward
 981 | 		if (val[row][i] == ' ')
 982 | 			count++;
 983 | 	}
 984 | 	dif = i - column;
 985 | 	if (count == dif && val[row][i] == opposite[4]) {
 986 | 		return true;
 987 | 	}
 988 | 	count = 1, i = 0;
 989 | 	for (i = column; i > 0 && val[row][i] != opposite[4]; i--) {						//same row leftward
 990 | 		if (val[row][i] == ' ')
 991 | 			count++;
 992 | 	}
 993 | 	dif = column - i;
 994 | 	if (count == dif && val[row][i] == opposite[4]) {
 995 | 		return true;
 996 | 	}
 997 | 	count = 1, i = 0, j = 0;
 998 | 	for (i = row, j = column; val[i][j] != opposite[4] && i > 0 && j < 7; i--, j++) {			//forward upward diagonal
 999 | 		if (val[i][j] == ' ')
1000 | 			count++;
1001 | 	}
1002 | 	dif = row - i;
1003 | 	if (count == dif && val[i][j] == opposite[4]) {
1004 | 		return true;
1005 | 	}//end up forward diagonal
1006 | 
1007 | 	count = 1, i = 0, j = 0;
1008 | 	for (i = row, j = column; val[i][j] != opposite[4] && i < 7 && j < 7; i++, j++) {			//forward downward diagonal
1009 | 		if (val[i][j] == ' ')
1010 | 			count++;
1011 | 	}
1012 | 	dif = i - row;
1013 | 	if (count == dif && val[i][j] == opposite[4]) {
1014 | 		return true;
1015 | 	}//end down forward diagonal 
1016 | 
1017 | 	count = 1, i = 0, j = 0;
1018 | 	for (i = row, j = column; val[i][j] != opposite[4] && i > 0 && j > 0; i--, j--) {				//backward up diagonal
1019 | 		if (val[i][j] == ' ')
1020 | 			count++;
1021 | 	}
1022 | 	dif = row - i;
1023 | 	if (count == dif && val[i][j] == opposite[4]) {
1024 | 		return true;
1025 | 	}//end up backward diagonal
1026 | 
1027 | 	count = 1, i = 0, j = 0;
1028 | 	for (i = row, j = column; val[i][j] != opposite[4] && i < 7 && j > 0; i++, j--) {				//downward backward diagonal
1029 | 		if (val[i][j] == ' ')
1030 | 			count++;
1031 | 	}
1032 | 	dif = i - row;
1033 | 	if (count == dif && val[i][j] == opposite[4]) {
1034 | 		return true;
1035 | 	}//end down backward diagonal
1036 | 	return false;
1037 | 
1038 | }
1039 | 
1040 | bool kingCheck(char val[8][8], int row, int column, char opposite[]) {
1041 | 	if (val[row + 1][column] == opposite[5] || val[row - 1][column] == opposite[5] || val[row + 1][column + 1] == opposite[5] || val[row + 1][column - 1] == opposite[5] || val[row - 1][column + 1] == opposite[5] || val[row - 1][column - 1] == opposite[5] || val[row][column + 1] == opposite[5] || val[row][column - 1] == opposite[5]) {
1042 | 		return true;
1043 | 	}
1044 | 	return false;
1045 | }
1046 | 
1047 | bool check(char val[8][8], int row, int column, char opposite[]) {
1048 | 	bool found = true;
1049 | 	if (turn == 'A')
1050 | 	{
1051 | 		found = pawnCheckforWhite(val, row, column, opposite);
1052 | 	}
1053 | 	else
1054 | 	{
1055 | 		found = pawnCheckforBlack(val, row, column, opposite);
1056 | 	}
1057 | 
1058 | 	if (found == true) {
1059 | 		return true;
1060 | 	}
1061 | 	else
1062 | 		found = rookCheck(val, row, column, opposite);
1063 | 	if (found == true)
1064 | 		return true;
1065 | 	else
1066 | 		found = knightCheck(val, row, column, opposite);
1067 | 	if (found == true)
1068 | 		return true;
1069 | 	else
1070 | 		found = bishopCheck(val, row, column, opposite);
1071 | 	if (found == true)
1072 | 		return true;
1073 | 	else
1074 | 		found = queenCheck(val, row, column, opposite);
1075 | 	if (found == true)
1076 | 		return true;
1077 | 	else
1078 | 		found = kingCheck(val, row, column, opposite);
1079 | 	if (found == true)
1080 | 		return true;
1081 | 	else
1082 | 		return false;
1083 | }
1084 | 
1085 | bool afterCheck(char val[8][8], int row, int column, int desRow, int desColumn, char temp, char opposite[]) {
1086 | 	bool found = true;
1087 | 	int indi = 0, indj = 0;
1088 | 	kingPosition(val, indi, indj);
1089 | 	if (check(val, indi, indj, opposite) == true)
1090 | 		found = false;
1091 | 	if (found == false) {
1092 | 		val[row][column] = val[desRow][desColumn];
1093 | 		val[desRow][desColumn] = temp;  //space
1094 | 		return false;
1095 | 	}
1096 | 	return true;
1097 | }
1098 | 
1099 | //Castling
1100 | bool castling(char val[8][8], int row, int column, int desRow, int desColumn, char opposite[], int& countK, int& countr_1, int& countr_2)
1101 | {
1102 | 	if (turn == 'A') {
1103 | 		opposite[0] = 'P', opposite[1] = 'R', opposite[2] = 'N', opposite[3] = 'B', opposite[4] = 'Q', opposite[5] = 'K';
1104 | 	}
1105 | 	else if (turn == 'B') {
1106 | 		opposite[0] = 'p', opposite[1] = 'r', opposite[2] = 'n', opposite[3] = 'b', opposite[4] = 'q', opposite[5] = 'k';
1107 | 	}
1108 | 	char ch = 32;
1109 | 	int count = 1, i = 0;
1110 | 	bool found = false, checker = true, option = false;
1111 | 
1112 | 	if (row == 0 || row == 7) {
1113 | 
1114 | 		//queen Side castling 
1115 | 		if (val[row][column] == opposite[5] && desColumn == column - 2 && column == 4 && val[desRow][desColumn] == ch) {
1116 | 			if (row == desRow && val[row][column - 4] == opposite[1]) {
1117 | 				if (countK == 1 && countr_1 == 1) {
1118 | 					count = 1;
1119 | 					for (i = column; i > 0; i--) {
1120 | 						if (val[row][i] == ' ')
1121 | 							count++;
1122 | 					}
1123 | 					int dif = column - i;
1124 | 					checkDestination(opposite);
1125 | 					if (count == dif) {
1126 | 						if (check(val, row, column, opposite) == true)
1127 | 							return true;
1128 | 						else
1129 | 							checker = check(val, row, column - 1, opposite);
1130 | 						if (checker == true)
1131 | 							return true;
1132 | 						else
1133 | 							checker = check(val, row, column - 2, opposite);
1134 | 						if (checker == true)
1135 | 							return true;
1136 | 						else
1137 | 						{
1138 | 							val[desRow][desColumn] = val[row][column];
1139 | 							val[row][column] = ' ';
1140 | 							val[row][column - 1] = val[row][column - 4];
1141 | 							val[row][column - 4] = ' ';
1142 | 							return false;
1143 | 						}
1144 | 					}
1145 | 				}
1146 | 			}
1147 | 		}
1148 | 
1149 | 		//king Side castling
1150 | 		if (val[row][column] == opposite[5] && desColumn == column + 2 && column == 4 && val[desRow][desColumn] == ch) {
1151 | 			if (row == desRow && val[row][column + 3] == opposite[1]) {
1152 | 				if (countK == 1 && countr_2 == 1) {
1153 | 					count = 1;
1154 | 					for (i = column; i < 7; i++) {
1155 | 						if (val[row][i] == ' ')
1156 | 							count++;
1157 | 					}
1158 | 					int dif = i - column;
1159 | 					checkDestination(opposite);
1160 | 					if (count == dif) {
1161 | 						if (check(val, row, column, opposite) == true)
1162 | 							return true;
1163 | 						else
1164 | 							checker = check(val, row, column - 1, opposite);
1165 | 						if (checker == true)
1166 | 							return true;
1167 | 						else
1168 | 							checker = check(val, row, column - 2, opposite);
1169 | 						if (checker == true)
1170 | 							return true;
1171 | 						else
1172 | 						{
1173 | 							val[desRow][desColumn] = val[row][column];
1174 | 							val[row][column] = ' ';
1175 | 							val[row][column + 1] = val[row][column + 3];
1176 | 							val[row][column + 3] = ' ';
1177 | 							return false;
1178 | 						}
1179 | 					}
1180 | 				}
1181 | 			}
1182 | 		}
1183 | 	}
1184 | 	return true;
1185 | }
1186 | 
1187 | //checkMate for PAWN
1188 | 
1189 | bool pawnCheckMate(char val[8][8], int row, int column, int desRow, int desColumn, char opposite[]) {
1190 | 	if (turn == 'A') {
1191 | 		char ch = 32;
1192 | 		//for empassent condition
1193 | 		if (val[desRow][desColumn] == ch && prevCoordinate[4] == 1 && prevCoordinate[6] == row && desRow == row - 1 && (desColumn == column + 1 || desColumn == column - 1))
1194 | 		{
1195 | 			val[prevCoordinate[6]][prevCoordinate[7]] = ch;
1196 | 			return true;
1197 | 		}
1198 | 
1199 | 		else if (val[desRow][desColumn] == opposite[0] || val[desRow][desColumn] == opposite[1] || val[desRow][desColumn] == opposite[2] || val[desRow][desColumn] == opposite[3] || val[desRow][desColumn] == opposite[4] || val[desRow][desColumn] == opposite[5])
1200 | 		{
1201 | 			if ((desRow == row - 1 && desColumn == column + 1) || (desRow == row - 1 && desColumn == column - 1))
1202 | 			{
1203 | 				return true;
1204 | 			}
1205 | 		}
1206 | 		else if (row == 6)
1207 | 		{
1208 | 			if ((desRow == row - 1 || desRow == row - 2) && column == desColumn && val[desRow][desColumn] == ch) {
1209 | 				if (desRow == row - 2 && val[row - 1][desColumn] == ch)
1210 | 				return true;
1211 | 				if (desRow == row - 1)
1212 | 					return true;
1213 | 			}
1214 | 		}
1215 | 		else if (desRow == row - 1 && column == desColumn)
1216 | 		{
1217 | 			if (val[desRow][desColumn] == ch) {
1218 | 				return true;
1219 | 			}
1220 | 		}
1221 | 	}
1222 | 	else
1223 | 	{
1224 | 		char ch = 32;
1225 | 		if (val[desRow][desColumn] == ch && prevCoordinate[0] == 6 && prevCoordinate[2] == row && desRow == row + 1 && (desColumn == column + 1 || desColumn == column - 1)) {
1226 | 			val[prevCoordinate[2]][prevCoordinate[3]] = ch;
1227 | 			return true;
1228 | 		}
1229 | 		else if (val[desRow][desColumn] == opposite[0] || val[desRow][desColumn] == opposite[1] || val[desRow][desColumn] == opposite[2] || val[desRow][desColumn] == opposite[3] || val[desRow][desColumn] == opposite[4] || val[desRow][desColumn] == opposite[5])
1230 | 		{
1231 | 			if (desRow == row + 1 && desColumn == column + 1 || desRow == row + 1 && desColumn == column - 1)
1232 | 			{
1233 | 				return true;
1234 | 			}
1235 | 		}
1236 | 		else if (row == 1)
1237 | 		{
1238 | 			if ((desRow == row + 1 || desRow == row + 2) && column == desColumn && val[desRow][desColumn] == ch) {
1239 | 				if (desRow == row + 2 && val[row + 1][desColumn] == ch)
1240 | 					return true;
1241 | 				if(desRow == row + 1)
1242 | 				return true;
1243 | 			}
1244 | 		}
1245 | 		else if (desRow == row + 1 && column == desColumn)
1246 | 		{
1247 | 			if (val[desRow][desColumn] == ch)
1248 | 				return true;
1249 | 		}
1250 | 	}
1251 | 	return false;
1252 | }
1253 | 
1254 | //checkmate
1255 | bool CheckForCheckmate(char val[8][8], char opposite[])
1256 | {
1257 | 	int indi = 0, indj = 0;
1258 | 	char savePiece = '\0';
1259 | 	checkDestination(opposite);
1260 | 	char ch = ' ';
1261 | 	char piece = '\0'; //declare var
1262 | 	for (int yi = 0; yi < 8; yi++)
1263 | 	{
1264 | 		for (int xi = 0; xi < 8; xi++)
1265 | 		{
1266 | 			if (turn == 'A') //if white...
1267 | 			{
1268 | 				piece = '\0';
1269 | 				if (val[yi][xi] == 'P') piece = 'P'; //check for pawn
1270 | 				else if (val[yi][xi] == 'N') piece = 'N'; //check for knight
1271 | 				else if (val[yi][xi] == 'B') piece = 'B'; //check for bishop
1272 | 				else if (val[yi][xi] == 'R') piece = 'R'; //check for rook
1273 | 				else if (val[yi][xi] == 'Q') piece = 'Q'; //check for queen
1274 | 				else if (val[yi][xi] == 'K') piece = 'K'; //check for king
1275 | 				for (int yf = 0; yf < 8; yf++)
1276 | 				{
1277 | 					for (int xf = 0; xf < 8; xf++)
1278 | 					{
1279 | 						if (piece == 'P')
1280 | 						{
1281 | 							if (pawnCheckMate(val, yi, xi, yf, xf, opposite) == true)
1282 | 							{
1283 | 								savePiece = val[yf][xf];
1284 | 								val[yf][xf] = 'P'; //set val
1285 | 								val[yi][xi] = ch; //set val
1286 | 								kingPosition(val, indi, indj);
1287 | 								bool checker = check(val, indi, indj, opposite);  //check if still in check
1288 | 								val[yf][xf] = savePiece; //set val
1289 | 								val[yi][xi] = 'P'; //set val
1290 | 								if (checker == false) return false; //check if white is in check
1291 | 								kingPosition(val, indi, indj);
1292 | 								if (check(val, indi, indj, opposite) == false)
1293 | 									return false;
1294 | 							}
1295 | 						}
1296 | 						else if (piece == 'N')
1297 | 						{
1298 | 							if (knightForWhite(val, yi, xi, yf, xf, opposite) == true)
1299 | 							{
1300 | 								savePiece = val[yf][xf];
1301 | 								val[yf][xf] = 'N'; //set val
1302 | 								val[yi][xi] = ch; //set val
1303 | 								kingPosition(val, indi, indj);
1304 | 								bool checker = check(val, indi, indj, opposite);  //check if still in check
1305 | 								val[yf][xf] = savePiece; //set val
1306 | 								val[yi][xi] = 'N'; //set val
1307 | 								if (checker == false) return false; //check if white is in check
1308 | 								kingPosition(val, indi, indj);
1309 | 								if (check(val, indi, indj, opposite) == false)
1310 | 									return false;
1311 | 							}
1312 | 						}
1313 | 						else if (piece == 'B')
1314 | 						{
1315 | 							if (bishopForWhite(val, yi, xi, yf, xf, opposite) == true)
1316 | 							{
1317 | 								savePiece = val[yf][xf];
1318 | 								val[yf][xf] = 'B'; //set val
1319 | 								val[yi][xi] = ch; //set val
1320 | 								kingPosition(val, indi, indj);
1321 | 								bool checker = check(val, indi, indj, opposite);  //check if still in check
1322 | 								val[yf][xf] = savePiece; //set val
1323 | 								val[yi][xi] = 'B'; //set val
1324 | 								if (checker == false) return false; //check if white is in check
1325 | 								kingPosition(val, indi, indj);
1326 | 								if (check(val, indi, indj, opposite) == false)
1327 | 									return false;
1328 | 
1329 | 							}
1330 | 						}
1331 | 						else if (piece == 'R')
1332 | 						{
1333 | 							if (rookForWhite(val, yi, xi, yf, xf, opposite) == true)
1334 | 							{
1335 | 								savePiece = val[yf][xf];
1336 | 								val[yf][xf] = 'R'; //set val
1337 | 								val[yi][xi] = ch; //set val
1338 | 								kingPosition(val, indi, indj);
1339 | 								bool checker = check(val, indi, indj, opposite);  //check if still in check
1340 | 								val[yf][xf] = savePiece; //set val
1341 | 								val[yi][xi] = 'R'; //set val
1342 | 								if (checker == false) return false; //check if white is in check
1343 | 								kingPosition(val, indi, indj);
1344 | 								if (check(val, indi, indj, opposite) == false)
1345 | 									return false;
1346 | 							}
1347 | 						}
1348 | 						else if (piece == 'Q')
1349 | 						{
1350 | 							if (queenForWhite(val, yi, xi, yf, xf, opposite) == true)
1351 | 							{
1352 | 								savePiece = val[yf][xf];
1353 | 								val[yf][xf] = 'Q'; //set val
1354 | 								val[yi][xi] = ch; //set val
1355 | 								kingPosition(val, indi, indj);
1356 | 								bool checker = check(val, indi, indj, opposite);  //check if still in check
1357 | 								val[yf][xf] = savePiece; //set val
1358 | 								val[yi][xi] = 'Q'; //set val
1359 | 								if (checker == false) return false; //check if white is in check
1360 | 								kingPosition(val, indi, indj);
1361 | 								if (check(val, indi, indj, opposite) == false)
1362 | 									return false;
1363 | 							}
1364 | 						}
1365 | 						else if (piece == 'K')
1366 | 						{
1367 | 							if (kingForWhite(val, yi, xi, yf, xf, opposite) == true)
1368 | 							{
1369 | 								savePiece = val[yf][xf];
1370 | 								val[yf][xf] = 'K'; //set val
1371 | 								val[yi][xi] = ch; //set val
1372 | 								kingPosition(val, indi, indj);
1373 | 								bool checker = check(val, indi, indj, opposite);  //check if still in check
1374 | 								val[yf][xf] = savePiece; //set val
1375 | 								val[yi][xi] = 'K'; //set val
1376 | 								if (checker == false) return false; //check if white is in check
1377 | 								kingPosition(val, indi, indj);
1378 | 								if (check(val, indi, indj, opposite) == false)
1379 | 									return false;
1380 | 							}
1381 | 						}
1382 | 					}
1383 | 				}
1384 | 			}
1385 | 			else if (turn == 'B') //if BLACK...
1386 | 			{
1387 | 				piece = ch;
1388 | 				if (val[yi][xi] == 'p') piece = 'p'; //check for pawn
1389 | 				else if (val[yi][xi] == 'n') piece = 'n'; //check for knight
1390 | 				else if (val[yi][xi] == 'b') piece = 'b'; //check for bishop
1391 | 				else if (val[yi][xi] == 'r') piece = 'r'; //check for rook
1392 | 				else if (val[yi][xi] == 'q') piece = 'q'; //check for queen
1393 | 				else if (val[yi][xi] == 'k') piece = 'k'; //check for king
1394 | 				for (int yf = 0; yf < 8; yf++)
1395 | 				{
1396 | 					for (int xf = 0; xf < 8; xf++)
1397 | 					{
1398 | 						savePiece = '\0';
1399 | 						if (piece == 'p')
1400 | 						{
1401 | 							if (pawnCheckMate(val, yi, xi, yf, xf, opposite) == true)
1402 | 							{
1403 | 								savePiece = val[yf][xf];
1404 | 								val[yf][xf] = 'p'; //set val
1405 | 								val[yi][xi] = ch; //set val
1406 | 								kingPosition(val, indi, indj);
1407 | 								bool checker = check(val, indi, indj, opposite);  //check if still in check
1408 | 								val[yf][xf] = savePiece; //set val
1409 | 								val[yi][xi] = 'p'; //set val
1410 | 								if (checker == false) return false; //check if white is in check
1411 | 								kingPosition(val, indi, indj);
1412 | 								if (check(val, indi, indj, opposite) == false)
1413 | 									return false;
1414 | 							}
1415 | 						}
1416 | 						else if (piece == 'n')
1417 | 						{
1418 | 							if (knightForWhite(val, yi, xi, yf, xf, opposite) == true)
1419 | 							{
1420 | 								savePiece = val[yf][xf];
1421 | 								val[yf][xf] = 'n'; //set val
1422 | 								val[yi][xi] = ch; //set val
1423 | 								kingPosition(val, indi, indj);
1424 | 								bool checker = check(val, indi, indj, opposite);  //check if still in check
1425 | 								val[yf][xf] = savePiece; //set val
1426 | 								val[yi][xi] = 'n'; //set val
1427 | 								if (checker == false) return false; //check if white is in check
1428 | 								kingPosition(val, indi, indj);
1429 | 								if (check(val, indi, indj, opposite) == false)
1430 | 									return false;
1431 | 							}
1432 | 						}
1433 | 						else if (piece == 'b')
1434 | 						{
1435 | 							if (bishopForWhite(val, yi, xi, yf, xf, opposite) == true)
1436 | 							{
1437 | 								savePiece = val[yf][xf];
1438 | 								val[yf][xf] = 'b'; //set val
1439 | 								val[yi][xi] = ch; //set val
1440 | 								kingPosition(val, indi, indj);
1441 | 								bool checker = check(val, indi, indj, opposite);  //check if still in check
1442 | 								val[yf][xf] = savePiece; //set val
1443 | 								val[yi][xi] = 'b'; //set val
1444 | 								if (checker == false) return false; //check if white is in check
1445 | 								kingPosition(val, indi, indj);
1446 | 								if (check(val, indi, indj, opposite) == false)
1447 | 									return false;
1448 | 							}
1449 | 						}
1450 | 						else if (piece == 'r')
1451 | 						{
1452 | 							if (rookForWhite(val, yi, xi, yf, xf, opposite) == true)
1453 | 							{
1454 | 								savePiece = val[yf][xf];
1455 | 								val[yf][xf] = 'r'; //set val
1456 | 								val[yi][xi] = ch; //set val
1457 | 								kingPosition(val, indi, indj);
1458 | 								bool checker = check(val, indi, indj, opposite);  //check if still in check
1459 | 								val[yf][xf] = savePiece; //set val
1460 | 								val[yi][xi] = 'r'; //set val
1461 | 								if (checker == false) return false; //check if white is in check
1462 | 								kingPosition(val, indi, indj);
1463 | 								if (check(val, indi, indj, opposite) == false)
1464 | 									return false;
1465 | 							}
1466 | 						}
1467 | 						else if (piece == 'q')
1468 | 						{
1469 | 							if (queenForWhite(val, yi, xi, yf, xf, opposite) == true)
1470 | 							{
1471 | 								savePiece = val[yf][xf];
1472 | 								val[yf][xf] = 'q'; //set val
1473 | 								val[yi][xi] = ch; //set val
1474 | 								kingPosition(val, indi, indj);
1475 | 								bool checker = check(val, indi, indj, opposite);  //check if still in check
1476 | 								val[yf][xf] = savePiece; //set val
1477 | 								val[yi][xi] = 'q'; //set val
1478 | 								if (checker == false) return false; //check if white is in check
1479 | 								kingPosition(val, indi, indj);
1480 | 								if (check(val, indi, indj, opposite) == false)
1481 | 									return false;
1482 | 							}
1483 | 						}
1484 | 						else if (piece == 'k')
1485 | 						{
1486 | 							checkDestination(opposite);
1487 | 							if (kingForWhite(val, yi, xi, yf, xf, opposite) == true)
1488 | 							{
1489 | 								savePiece = val[yf][xf];
1490 | 								val[yf][xf] = 'k'; //set val
1491 | 								val[yi][xi] = ch; //set val
1492 | 								kingPosition(val, indi, indj);
1493 | 								bool checker = check(val, indi, indj, opposite);  //check if still in check
1494 | 								val[yf][xf] = savePiece; //set val
1495 | 								val[yi][xi] = 'k'; //set val
1496 | 								if (checker == false) return false; //check if white is in check
1497 | 								kingPosition(val, indi, indj);
1498 | 								if (check(val, indi, indj, opposite) == false)
1499 | 									return false;
1500 | 							}
1501 | 						}
1502 | 					}
1503 | 				}
1504 | 			}
1505 | 		}
1506 | 	}
1507 | 	return true;
1508 | }
1509 | 
1510 | //stalemate
1511 | bool stalemate(char val[8][8], char opposite[]) {
1512 | 	int indi = 0, indj = 0;
1513 | 		char savePiece = '\0';
1514 | 		checkDestination(opposite);
1515 | 		char ch = ' ';
1516 | 		char piece = '\0'; //declare var
1517 | 		for (int yi = 0; yi < 8; yi++)
1518 | 		{
1519 | 			for (int xi = 0; xi < 8; xi++)
1520 | 			{
1521 | 				if (turn == 'A') //if white...
1522 | 				{
1523 | 					piece = '\0';
1524 | 					if (val[yi][xi] == 'P') piece = 'P'; //check for pawn
1525 | 					else if (val[yi][xi] == 'N') piece = 'N'; //check for knight
1526 | 					else if (val[yi][xi] == 'B') piece = 'B'; //check for bishop
1527 | 					else if (val[yi][xi] == 'R') piece = 'R'; //check for rook
1528 | 					else if (val[yi][xi] == 'Q') piece = 'Q'; //check for queen
1529 | 					else if (val[yi][xi] == 'K') piece = 'K'; //check for king
1530 | 					for (int yf = 0; yf < 8; yf++)
1531 | 					{
1532 | 						for (int xf = 0; xf < 8; xf++)
1533 | 						{
1534 | 							if (piece == 'P')
1535 | 							{
1536 | 								if (xi != xf || yi != yf) {
1537 | 									if (pawnCheckMate(val, yi, xi, yf, xf, opposite) == true)
1538 | 									{
1539 | 										savePiece = val[yf][xf];
1540 | 										val[yf][xf] = 'P'; //set val
1541 | 										val[yi][xi] = ch; //set val
1542 | 										kingPosition(val, indi, indj);
1543 | 										bool checker = check(val, indi, indj, opposite);  //check if still in check
1544 | 										val[yf][xf] = savePiece; //set val
1545 | 										val[yi][xi] = 'P'; //set val
1546 | 										if (checker == false) return false; //check if white is in check
1547 | 									}
1548 | 								}
1549 | 							}
1550 | 							else if (piece == 'N')
1551 | 							{
1552 | 								if (xi != xf || yi != yf) {
1553 | 									if (knightForWhite(val, yi, xi, yf, xf, opposite) == true)
1554 | 									{
1555 | 										savePiece = val[yf][xf];
1556 | 										val[yf][xf] = 'N'; //set val
1557 | 										val[yi][xi] = ch; //set val
1558 | 										kingPosition(val, indi, indj);
1559 | 										bool checker = check(val, indi, indj, opposite);  //check if still in check
1560 | 										val[yf][xf] = savePiece; //set val
1561 | 										val[yi][xi] = 'N'; //set val
1562 | 										if (checker == false) return false; //check if white is in check
1563 | 									}
1564 | 								}
1565 | 							}
1566 | 							else if (piece == 'B')
1567 | 							{
1568 | 								if (xi != xf || yi != yf) {
1569 | 									if (bishopForWhite(val, yi, xi, yf, xf, opposite) == true)
1570 | 									{
1571 | 										savePiece = val[yf][xf];
1572 | 										val[yf][xf] = 'B'; //set val
1573 | 										val[yi][xi] = ch; //set val
1574 | 										kingPosition(val, indi, indj);
1575 | 										bool checker = check(val, indi, indj, opposite);  //check if still in check
1576 | 										val[yf][xf] = savePiece; //set val
1577 | 										val[yi][xi] = 'B'; //set val
1578 | 										if (checker == false) return false; //check if white is in check
1579 | 
1580 | 									}
1581 | 								}
1582 | 							}
1583 | 							else if (piece == 'R')
1584 | 							{
1585 | 								if (xi != xf || yi != yf) {
1586 | 									if (rookForWhite(val, yi, xi, yf, xf, opposite) == true)
1587 | 									{
1588 | 										savePiece = val[yf][xf];
1589 | 										val[yf][xf] = 'R'; //set val
1590 | 										val[yi][xi] = ch; //set val
1591 | 										kingPosition(val, indi, indj);
1592 | 										bool checker = check(val, indi, indj, opposite);  //check if still in check
1593 | 										val[yf][xf] = savePiece; //set val
1594 | 										val[yi][xi] = 'R'; //set val
1595 | 										if (checker == false) return false; //check if white is in check
1596 | 									}
1597 | 								}
1598 | 							}
1599 | 							else if (piece == 'Q')
1600 | 							{
1601 | 								if (xi != xf || yi != yf) {
1602 | 									if (queenForWhite(val, yi, xi, yf, xf, opposite) == true)
1603 | 									{
1604 | 										savePiece = val[yf][xf];
1605 | 										val[yf][xf] = 'Q'; //set val
1606 | 										val[yi][xi] = ch; //set val
1607 | 										kingPosition(val, indi, indj);
1608 | 										bool checker = check(val, indi, indj, opposite);  //check if still in check
1609 | 										val[yf][xf] = savePiece; //set val
1610 | 										val[yi][xi] = 'Q'; //set val
1611 | 										if (checker == false) return false; //check if white is in check
1612 | 									}
1613 | 								}
1614 | 							}
1615 | 							else if (piece == 'K')
1616 | 							{
1617 | 								if (xi != xf || yi != yf) {
1618 | 									if (kingForWhite(val, yi, xi, yf, xf, opposite) == true)
1619 | 									{
1620 | 										savePiece = val[yf][xf];
1621 | 										val[yf][xf] = 'K'; //set val
1622 | 										val[yi][xi] = ch; //set val
1623 | 										kingPosition(val, indi, indj);
1624 | 										bool checker = check(val, indi, indj, opposite);  //check if still in check
1625 | 										val[yf][xf] = savePiece; //set val
1626 | 										val[yi][xi] = 'K'; //set val
1627 | 										if (checker == false) return false; //check if white is in check
1628 | 									}
1629 | 								}
1630 | 							}
1631 | 						}
1632 | 					}
1633 | 				}
1634 | 
1635 | 				//if turn is of BLACK
1636 | 				else if (turn == 'B') //if BLACK...
1637 | 				{
1638 | 					piece = ch;
1639 | 					if (val[yi][xi] == 'p') piece = 'p'; //check for pawn
1640 | 					else if (val[yi][xi] == 'n') piece = 'n'; //check for knight
1641 | 					else if (val[yi][xi] == 'b') piece = 'b'; //check for bishop
1642 | 					else if (val[yi][xi] == 'r') piece = 'r'; //check for rook
1643 | 					else if (val[yi][xi] == 'q') piece = 'q'; //check for queen
1644 | 					else if (val[yi][xi] == 'k') piece = 'k'; //check for king
1645 | 					for (int yf = 0; yf < 8; yf++)
1646 | 					{
1647 | 						for (int xf = 0; xf < 8; xf++)
1648 | 						{
1649 | 							savePiece = '\0';
1650 | 							if (piece == 'p')
1651 | 							{
1652 | 								if (xi != xf || yi != yf) {
1653 | 									if (pawnCheckMate(val, yi, xi, yf, xf, opposite) == true)
1654 | 									{
1655 | 										savePiece = val[yf][xf];
1656 | 										val[yf][xf] = 'p'; //set val
1657 | 										val[yi][xi] = ch; //set val
1658 | 										kingPosition(val, indi, indj);
1659 | 										bool checker = check(val, indi, indj, opposite);  //check if still in check
1660 | 										val[yf][xf] = savePiece; //set val
1661 | 										val[yi][xi] = 'p'; //set val
1662 | 										if (checker == false) return false; //check if white is in check
1663 | 									}
1664 | 								}
1665 | 							}
1666 | 							else if (piece == 'n')
1667 | 							{
1668 | 								if (xi != xf || yi != yf) {
1669 | 									if (knightForWhite(val, yi, xi, yf, xf, opposite) == true)
1670 | 									{
1671 | 										savePiece = val[yf][xf];
1672 | 										val[yf][xf] = 'n'; //set val
1673 | 										val[yi][xi] = ch; //set val
1674 | 										kingPosition(val, indi, indj);
1675 | 										bool checker = check(val, indi, indj, opposite);  //check if still in check
1676 | 										val[yf][xf] = savePiece; //set val
1677 | 										val[yi][xi] = 'n'; //set val
1678 | 										if (checker == false) return false; //check if white is in check
1679 | 									}
1680 | 								}
1681 | 							}
1682 | 							else if (piece == 'b')
1683 | 							{
1684 | 								if (xi != xf || yi != yf) {
1685 | 									if (bishopForWhite(val, yi, xi, yf, xf, opposite) == true)
1686 | 									{
1687 | 										savePiece = val[yf][xf];
1688 | 										val[yf][xf] = 'b'; //set val
1689 | 										val[yi][xi] = ch; //set val
1690 | 										kingPosition(val, indi, indj);
1691 | 										bool checker = check(val, indi, indj, opposite);  //check if still in check
1692 | 										val[yf][xf] = savePiece; //set val
1693 | 										val[yi][xi] = 'b'; //set val
1694 | 										if (checker == false) return false; //check if white is in check
1695 | 									}
1696 | 								}
1697 | 							}
1698 | 							else if (piece == 'r')
1699 | 							{
1700 | 								if (xi != xf || yi != yf) {
1701 | 									if (rookForWhite(val, yi, xi, yf, xf, opposite) == true)
1702 | 									{
1703 | 										savePiece = val[yf][xf];
1704 | 										val[yf][xf] = 'r'; //set val
1705 | 										val[yi][xi] = ch; //set val
1706 | 										kingPosition(val, indi, indj);
1707 | 										bool checker = check(val, indi, indj, opposite);  //check if still in check
1708 | 										val[yf][xf] = savePiece; //set val
1709 | 										val[yi][xi] = 'r'; //set val
1710 | 										if (checker == false) return false; //check if white is in check
1711 | 									}
1712 | 								}
1713 | 							}
1714 | 							else if (piece == 'q')
1715 | 							{
1716 | 								if (xi != xf || yi != yf) {
1717 | 									if (queenForWhite(val, yi, xi, yf, xf, opposite) == true)
1718 | 									{
1719 | 										savePiece = val[yf][xf];
1720 | 										val[yf][xf] = 'q'; //set val
1721 | 										val[yi][xi] = ch; //set val
1722 | 										kingPosition(val, indi, indj);
1723 | 										bool checker = check(val, indi, indj, opposite);  //check if still in check
1724 | 										val[yf][xf] = savePiece; //set val
1725 | 										val[yi][xi] = 'q'; //set val
1726 | 										if (checker == false) return false; //check if white is in check
1727 | 									}
1728 | 								}
1729 | 							}
1730 | 							else if (piece == 'k')
1731 | 							{
1732 | 								if (xi != xf || yi != yf) {
1733 | 									checkDestination(opposite);
1734 | 									if (kingForWhite(val, yi, xi, yf, xf, opposite) == true)
1735 | 									{
1736 | 										savePiece = val[yf][xf];
1737 | 										val[yf][xf] = 'k'; //set val
1738 | 										val[yi][xi] = ch; //set val
1739 | 										kingPosition(val, indi, indj);
1740 | 										bool checker = check(val, indi, indj, opposite);  //check if still in check
1741 | 										val[yf][xf] = savePiece; //set val
1742 | 										val[yi][xi] = 'k'; //set val
1743 | 										if (checker == false) return false; //check if white is in check
1744 | 									}
1745 | 								}
1746 | 							}
1747 | 						}
1748 | 					}
1749 | 				}
1750 | 			}
1751 | 		}
1752 | 	return true;
1753 | }
1754 | 
1755 | 
1756 | 
1757 | //turns of player 
1758 | int playerTurn(char val[8][8], bool& checkA, bool& checkB, int& countAK, int& countAr_1, int& countAr_2, int& countBk, int& countBr_1, int& countBr_2)
1759 | {
1760 | 	//initialize variables
1761 | 	int rowA=9, columnA=9, desColumnA=9, desRowA=9, rowB=9, columnB=9, desColumnB=9, desRowB=9;
1762 | 	int indi = 0, indj = 0;
1763 | 	char col, desCol, ch = 32, temp = '\0';
1764 | 	bool found2 = true;
1765 | 
1766 | 
1767 | 	//50 consecutive moves(no pawn move & no piece capture)
1768 | 	int presentPieces = 0;
1769 | 	for (int i = 0; i < 8; i++) {
1770 | 		for (int j = 0; j < 8; j++) {
1771 | 			if (val[i][j] != ' ') {			
1772 | 				presentPieces++;
1773 | 			}
1774 | 		}
1775 | 	}
1776 | 	if (presentPieces < countPreviousPieces) {				//compare present pieces with previous pieces
1777 | 		countPreviousPieces = presentPieces;
1778 | 		consecutiveMoves = 0;
1779 | 	}
1780 | 	if (consecutiveMoves == 50) {
1781 | 		cout << "::GAME DRAW::\n::CONSECUTIVE 50 MOVES NEITHER ANY PEICE CAPTURE NOR PAWN MOVE::\n";
1782 | 		return 1;
1783 | 	}
1784 | 
1785 | 
1786 | 
1787 | 	//draw condition (insufficient pieces left)
1788 | 	int pieceCount = 0, bishopCountA = 0, bishopCountB = 0;
1789 | 	for (int i = 0; i < 8; i++) {
1790 | 		for (int j = 0; j < 8; j++) {
1791 | 			if ((val[i][j] != 'K' && val[i][j] != 'k' && val[i][j] != ' ' && (val[i][j] != 'B' && val[i][j] != 'b'))) {
1792 | 				pieceCount++;
1793 | 			}
1794 | 			if (val[i][j] == 'B')
1795 | 				bishopCountA++;
1796 | 			if (val[i][j] == 'b')
1797 | 				bishopCountB++;
1798 | 		}
1799 | 	}
1800 | 
1801 | 	//if one king+bishop && an opponent king remain, then draw
1802 | 	if (pieceCount == 0 && ((bishopCountA == 1 && bishopCountB == 0) || (bishopCountA == 0 && bishopCountB == 1))) {
1803 | 		cout << "::GAME DARW DUE TO INSUFFICIENT PIECES::\n\n";
1804 | 		return 1;
1805 | 	}
1806 | 
1807 | 
1808 | 
1809 | 	//TURN OF PLAYER WHITE(A)
1810 | 	if (turn == 'A')				//turn of white player
1811 | 	{
1812 | 		cout << "PLAYER WHITE TURN(UPPER CASE)\n\n";
1813 | 
1814 | 		//put opponent pieces in opposite[] array 
1815 | 		checkDestination(opposite);
1816 | 		
1817 | 		//indexes where king is placed
1818 | 		bool cond = true;
1819 | 		indi = 0, indj = 0;
1820 | 
1821 | 		//finding index where king is placed
1822 | 		for (int i = 0; i < 8 && cond == true; i++) {
1823 | 			for (int j = 0; j < 8; j++) {
1824 | 				if (val[i][j] == 'K') {
1825 | 					indi = i;
1826 | 					indj = j;
1827 | 					cond = false;
1828 | 					break;
1829 | 				}
1830 | 			}
1831 | 		}
1832 | 
1833 | 
1834 | 
1835 | 		//checkmate
1836 | 		bool checkMate = CheckForCheckmate(val, opposite);
1837 | 		if (checkMate == true) {                     
1838 | 			if (foolmateA == 2) {
1839 | 				cout << "::FOOLS MATE::\n\n";				//if foolmate
1840 | 			}
1841 | 			else
1842 | 			{
1843 | 				cout << "::CHECKMATE::\n\n";			//if checkmate
1844 | 			}
1845 | 			cout << "::PLAYER BLACK WINS THE GAME::\n\n";
1846 | 				return 1;					
1847 | 		}
1848 | 		checkA = check(val, indi, indj, opposite);
1849 | 		
1850 | 		//check on player WHITE
1851 | 		if (checkA == true) 
1852 | 		{														//if player WHITE(A) is in check
1853 | 			cout << "::PLAYER WHITE IS IN CHECK::\n\n";
1854 | 		}
1855 | 
1856 | 		else {														//stalemate
1857 | 			bool staMate = stalemate(val, opposite);
1858 | 			if (staMate == true) {
1859 | 				cout << "::STALEMATE::\n\n";
1860 | 				
1861 | 				//if mode is classic then compare time
1862 | 				if (mode == 'C' || mode == 'c') 
1863 | 				{
1864 | 					if (classicTimerA > classicTimerB)
1865 | 					{
1866 | 						cout << "::PLAYER BLACK WINS THE GAME DUE TO TIME::\n";
1867 | 						return 1;
1868 | 					}
1869 | 					else if (classicTimerA < classicTimerB) 
1870 | 					{
1871 | 						cout << "::PLAYER WHITE WINS THE GAME DUE TO TIME::\n";
1872 | 						return 1;
1873 | 					}
1874 | 				}
1875 | 
1876 | 				cout << "::GAME DRAW::\n\n";
1877 | 				return 1;  
1878 | 			}
1879 | 		}
1880 | 
1881 | 		char userChoice = '\0';
1882 | 		if (mode != 'L' && mode != 'l') {
1883 | 		//conditions for draw game (user choice)
1884 | 		cout << "::PRESS H FOR HAND SHAKE::\n";
1885 | 		cout << "::PRESS R FOR RESIGN::\n";
1886 | 		cin>>userChoice;
1887 | 
1888 | 		//handshake
1889 | 			if (userChoice == 'H') {
1890 | 				char handshakeB = '\0';
1891 | 				cout << "::PLAYER WHITE WANT TO HANDSHAKE::\n::PRESS H TO HAND SHAKE::\n";
1892 | 				cin >> handshakeB;
1893 | 				if (userChoice == 'H' && handshakeB == 'H') {
1894 | 
1895 | 					cout << "::HAND SHAKE::\n\n";
1896 | 
1897 | 					//if mode is classic, then compare time
1898 | 					if (mode == 'C' || mode == 'c')
1899 | 					{
1900 | 						if (classicTimerA > classicTimerB)
1901 | 						{
1902 | 							cout << "::PLAYER BLACK WINS THE GAME DUE TO TIME::\n";
1903 | 							return 1;
1904 | 						}
1905 | 						else if (classicTimerA < classicTimerB)
1906 | 						{
1907 | 							cout << "::PLAYER WHITE WINS THE GAME DUE TO TIME::\n";
1908 | 							return 1;
1909 | 						}
1910 | 					}
1911 | 					cout << "::GAME DRAW BY HAND SHAKE::\n\n";
1912 | 					return 1;
1913 | 				}
1914 | 			}
1915 | 		}
1916 | 
1917 | 
1918 | 		//check for resign (resign not include in lightening mode)
1919 | 		if (mode != 'L' && mode != 'l') {
1920 | 			if (userChoice == 'R' || userChoice == 'r') {
1921 | 				cout << "::PLAYER WHITE RESIGN::\n\n";
1922 | 				cout << "::PLAYER BLACK WINS THE GAME::\n\n";
1923 | 				return 1;
1924 | 			}
1925 | 		}
1926 | 		
1927 | 
1928 | 		//games mode
1929 | 		if (mode == 'L' || mode == 'l') {
1930 | 			lightningTime();
1931 | 		}
1932 | 		else if (mode == 'R' || mode == 'r') {
1933 | 				rapidTime(rapidTimerA);
1934 | 		}
1935 | 		else if (mode == 'B' || mode == 'b') {
1936 | 			blitzTime(blitzTimerA);
1937 | 		}
1938 | 		else if (mode == 'C' || mode == 'c') {
1939 | 			classicTime(classicTimerA, hourA,minA,secA);
1940 | 		}
1941 | 
1942 | 		//input source position
1943 | 		cout << "MOVE FROM: ";
1944 | 		cin >> col >> rowA;
1945 | 		
1946 | 		//convert virtual index of row into actual index of row
1947 | 		rowA = 8 - rowA;
1948 | 
1949 | 		//convert alphabets column into integer column using switch
1950 | 		switch (col) {
1951 | 		case 'a': columnA = 0; break;
1952 | 		case 'b': columnA = 1; break;
1953 | 		case 'c': columnA = 2; break;
1954 | 		case 'd': columnA = 3; break;
1955 | 		case 'e': columnA = 4; break;
1956 | 		case 'f': columnA = 5; break;
1957 | 		case 'g': columnA = 6; break;
1958 | 		case 'h': columnA = 7; break;
1959 | 		default:
1960 | 		{
1961 | 			cout << "\t\t\t\t\t ****************| Invalid Choice |*****************\n";
1962 | 			playerTurn(val, checkA, checkB, countAK, countAr_1, countAr_2, countBk, countBr_1, countBr_2);
1963 | 			break;
1964 | 		}
1965 | 		}
1966 | 
1967 | 		//input destination position
1968 | 		cout << "TO: ";
1969 | 		cin >> desCol >> desRowA;
1970 | 
1971 | 		//convert virtual index of destination row into actual index of destination row
1972 | 		desRowA = 8 - desRowA;
1973 | 		
1974 | 		// convert alphabets destination column into integer destination column using switch
1975 | 		switch (desCol) {
1976 | 		case 'a': desColumnA = 0; break;
1977 | 		case 'b': desColumnA = 1; break;
1978 | 		case 'c': desColumnA = 2; break;
1979 | 		case 'd': desColumnA = 3; break;
1980 | 		case 'e': desColumnA = 4; break;
1981 | 		case 'f': desColumnA = 5; break;
1982 | 		case 'g': desColumnA = 6; break;
1983 | 		case 'h': desColumnA = 7; break;
1984 | 		default:
1985 | 		{
1986 | 			cout << "\t\t\t\t\t ****************| Invalid Choice |*****************\n";
1987 | 			playerTurn(val, checkA, checkB, countAK, countAr_1, countAr_2, countBk, countBr_1, countBr_2);
1988 | 			break;
1989 | 		}
1990 | 		}
1991 | 
1992 | 		//store position of last moves
1993 | 		prevCoordinate[0] = rowA;
1994 | 		prevCoordinate[1] = columnA;
1995 | 		prevCoordinate[2] = desRowA;
1996 | 		prevCoordinate[3] = desColumnA;
1997 | 	}
1998 | 
1999 | 	//turn of PLAYER black
2000 | 	else if (turn == 'B')
2001 | 	{
2002 | 		cout << "PLAYER BLACK TURN(SMALL CASE)\n\n";
2003 | 		//put opponent pieces in opposite[] array 
2004 | 		checkDestination(opposite);
2005 | 
2006 | 		//finding index where king is placed
2007 | 		bool cond = true;
2008 | 		indi = 0, indj = 0;
2009 | 		for (int i = 0; i < 8 && cond == true; i++) {
2010 | 			for (int j = 0; j < 8; j++) {
2011 | 				if (val[i][j] == 'k') {
2012 | 					indi = i;
2013 | 					indj = j;
2014 | 					cond = false;
2015 | 					break;
2016 | 				}
2017 | 			}
2018 | 		}
2019 | 
2020 | 		//checkmate
2021 | 		bool checkMate = CheckForCheckmate(val, opposite);
2022 | 		if (checkMate == true) {
2023 | 			if (foolmateB == 2) {
2024 | 				cout << "::FOOLS MATE::\n\n";				//if foolmate
2025 | 			}
2026 | 			else
2027 | 			{
2028 | 				cout << "::CHECKMATE::\n\n";			//if checkmate
2029 | 			}
2030 | 			cout << "::PLAYER WHITE WINS THE GAME::\n\n";
2031 | 			return 1;
2032 | 		}
2033 | 		checkB = check(val, indi, indj, opposite);
2034 | 		if (checkB == true)
2035 | 		{						//if player B is in check
2036 | 			cout << "::PLAYER BLACK IS IN CHECK::\n\n";
2037 | 		}
2038 | 
2039 | 		else
2040 | 		{									//if stalemate
2041 | 			bool staMate = stalemate(val, opposite);
2042 | 			if (staMate == true) {
2043 | 				cout << "::STALEMATE::\n\n";
2044 | 
2045 | 				//if mode is classic, then compare time
2046 | 				if (mode == 'C' || mode == 'c')
2047 | 				{
2048 | 					if (classicTimerA > classicTimerB)
2049 | 					{
2050 | 						cout << "::PLAYER BLACK WINS THE GAME DUE TO TIME::\n";
2051 | 						return 1;
2052 | 					}
2053 | 					else if (classicTimerA < classicTimerB)
2054 | 					{
2055 | 						cout << "::PLAYER WHITE WINS THE GAME DUE TO TIME::\n";
2056 | 						return 1;
2057 | 					}
2058 | 				}
2059 | 				cout << "::GAME DRAW::\n\n";
2060 | 				return 1;
2061 | 			}
2062 | 		}
2063 | 
2064 | 
2065 | 		char userChoice = '\0';
2066 | 		if (mode != 'L' && mode != 'l')
2067 | 		{
2068 | 		//conditions for draw game
2069 | 		cout << "::ENTER H FOR HAND SHAKE::\n";
2070 | 		cout << "::PRESS R FOR RESIGN::\n";
2071 | 		cin >> userChoice;
2072 | 		
2073 | 		//handshake
2074 | 			char handshakeA = '\0';
2075 | 			if (userChoice == 'H') {
2076 | 				cout << "::PLAYER BLACK WANTS TO HANDSHAKE::\n::PRESS H TO HAND SHAKE::\n\n";
2077 | 				cin >> handshakeA;
2078 | 			}
2079 | 				if (handshakeA == 'H' && userChoice == 'H')
2080 | 				{
2081 | 					cout << "::HAND SHAKE DONE::\n\n";
2082 | 					//if mode is classic, then compare time
2083 | 					if (mode == 'C' || mode == 'c')
2084 | 					{
2085 | 						if (classicTimerA > classicTimerB)
2086 | 						{
2087 | 							cout << "::PLAYER BLACK WINS THE GAME DUE TO TIME::\n";
2088 | 							return 1;
2089 | 						}
2090 | 						else if (classicTimerA < classicTimerB)
2091 | 						{
2092 | 							cout << "::PLAYER WHITE WINS THE GAME DUE TO TIME::\n";
2093 | 							return 1;
2094 | 						}
2095 | 					}
2096 | 					cout << "::GAME DRAW BY HAND SHAKE::\n\n";
2097 | 					return 1;
2098 | 				}
2099 | 			}
2100 | 
2101 | 
2102 | 
2103 | 		//check for resign (resign not include in lightening mode)
2104 | 		if (mode != 'L' && mode != 'l') {
2105 | 			if (userChoice == 'R' || userChoice == 'r') {
2106 | 				cout << "::PLAYER BLACK RESIGN::\n\n";
2107 | 				cout << "::PLAYER WHITE WINS THE GAME::\n\n";
2108 | 				return 1;
2109 | 			}
2110 | 		}
2111 | 
2112 | 
2113 | 		//games mode
2114 | 		if (mode == 'L' || mode == 'l') {
2115 | 			lightningTime();
2116 | 		}
2117 | 		else if (mode == 'R' || mode == 'r') {
2118 | 			rapidTime(rapidTimerB);
2119 | 		}
2120 | 		else if (mode == 'B' || mode == 'b') {
2121 | 			blitzTime(blitzTimerB);
2122 | 		}
2123 | 		else if (mode == 'C' || mode == 'c') {
2124 | 			classicTime(classicTimerB, hourB, minB, secB);
2125 | 		}
2126 | 
2127 | 		
2128 | 		//input source position
2129 | 		cout << "MOVE FROM: ";
2130 | 		cin >> col >> rowB;
2131 | 		
2132 | 		//convert virtual index of row into actual index of row
2133 | 		rowB = 8 - rowB;
2134 | 
2135 | 		//convert alphabets column into integer column using switch
2136 | 		switch (col) {
2137 | 		case 'a': columnB = 0; break;
2138 | 		case 'b': columnB = 1; break;
2139 | 		case 'c': columnB = 2; break;
2140 | 		case 'd': columnB = 3; break;
2141 | 		case 'e': columnB = 4; break;
2142 | 		case 'f': columnB = 5; break;
2143 | 		case 'g': columnB = 6; break;
2144 | 		case 'h': columnB = 7; break;
2145 | 		default:
2146 | 		{
2147 | 			cout << "\t\t\t\t\t ****************| Invalid Choice |*****************\n";
2148 | 			playerTurn(val, checkA, checkB, countAK, countAr_1, countAr_2, countBk, countBr_1, countBr_2);
2149 | 			break;
2150 | 		}
2151 | 		}
2152 | 
2153 | 		cout << "TO: ";
2154 | 		cin >> desCol >> desRowB;
2155 | 
2156 | 		//convert virtual index of destination row into actual index of destination row
2157 | 		desRowB = 8 - desRowB;
2158 | 
2159 | 		// convert alphabets destination column into integer destination column using switch
2160 | 		switch (desCol) {
2161 | 		case 'a': desColumnB = 0; break;
2162 | 		case 'b': desColumnB = 1; break;
2163 | 		case 'c': desColumnB = 2; break;
2164 | 		case 'd': desColumnB = 3; break;
2165 | 		case 'e': desColumnB = 4; break;
2166 | 		case 'f': desColumnB = 5; break;
2167 | 		case 'g': desColumnB = 6; break;
2168 | 		case 'h': desColumnB = 7; break;
2169 | 		default:
2170 | 		{
2171 | 			cout << "\t\t\t\t\t ****************| Invalid Choice |*****************\n";
2172 | 			playerTurn(val, checkA, checkB, countAK, countAr_1, countAr_2, countBk, countBr_1, countBr_2);
2173 | 			break;
2174 | 		}
2175 | 		}
2176 | 
2177 | 		//store position of last moves
2178 | 		prevCoordinate[4] = rowB;
2179 | 		prevCoordinate[5] = columnB;
2180 | 		prevCoordinate[6] = desRowB;
2181 | 		prevCoordinate[7] = desColumnB;
2182 | 	}
2183 | 	//PLAYER A TURN
2184 | 	if (turn == 'A')
2185 | 	{
2186 | 		checkDestination(opposite);
2187 | 		if (val[rowA][columnA] == 'P')
2188 | 		{
2189 | 			temp = val[desRowA][desColumnA];
2190 | 			bool found = pawnForWhite(val, rowA, columnA, desRowA, desColumnA, opposite);
2191 | 			found2 = afterCheck(val, rowA, columnA, desRowA, desColumnA, temp, opposite);
2192 | 			if (found == false || found2 == false)
2193 | 			{
2194 | 				cout << "\t\t\t\t\t ****************| Invalid Choice |*****************\n";
2195 | 				playerTurn(val, checkA, checkB, countAK, countAr_1, countAr_2, countBk, countBr_1, countBr_2);
2196 | 			}
2197 | 			else {
2198 | 				if (mode == 'R' || mode == 'r') {
2199 | 					rapidTimerA = rapidTimerA + 10;
2200 | 				}
2201 | 				consecutiveMoves = 0;
2202 | 				foolmateA++;
2203 | 				replayStore(rowA, col, desRowA, desCol);
2204 | 				turn = 'B';
2205 | 			}
2206 | 		}
2207 | 		else if (val[rowA][columnA] == 'R')
2208 | 		{
2209 | 			checkDestination(opposite);
2210 | 			bool found = rookForWhite(val, rowA, columnA, desRowA, desColumnA, opposite);
2211 | 			if (found == true) {
2212 | 				temp = val[desRowA][desColumnA];
2213 | 				val[desRowA][desColumnA] = val[rowA][columnA];
2214 | 				val[rowA][columnA] = ch;
2215 | 			}
2216 | 			found2 = afterCheck(val, rowA, columnA, desRowA, desColumnA, temp, opposite);
2217 | 			if (found == false || found2 == false)
2218 | 			{
2219 | 				cout << "\t\t\t\t\t ****************| Invalid Choice |*****************\n";
2220 | 				playerTurn(val, checkA, checkB, countAK, countAr_1, countAr_2, countBk, countBr_1, countBr_2);
2221 | 			}
2222 | 			else
2223 | 			{
2224 | 				if (mode == 'R' || mode == 'r') {
2225 | 					rapidTimerA = rapidTimerA + 10;
2226 | 				}
2227 | 				consecutiveMoves++;
2228 | 				foolmateA++;
2229 | 				replayStore(rowA, col, desRowA, desCol);
2230 | 				turn = 'B';
2231 | 			}
2232 | 		}
2233 | 		else if (val[rowA][columnA] == 'N')
2234 | 		{
2235 | 			bool found = knightForWhite(val, rowA, columnA, desRowA, desColumnA, opposite);
2236 | 			if (found == true) {
2237 | 				temp = val[desRowA][desColumnA];
2238 | 				val[desRowA][desColumnA] = val[rowA][columnA];
2239 | 				val[rowA][columnA] = ch;
2240 | 			}
2241 | 			found2 = afterCheck(val, rowA, columnA, desRowA, desColumnA, temp, opposite);
2242 | 			if (found == false || found2 == false)
2243 | 			{
2244 | 				cout << "\t\t\t\t\t ****************| Invalid Choice |*****************\n";
2245 | 				playerTurn(val, checkA, checkB, countAK, countAr_1, countAr_2, countBk, countBr_1, countBr_2);
2246 | 			}
2247 | 			else {
2248 | 				if (mode == 'R' || mode == 'r') {
2249 | 					rapidTimerA = rapidTimerA + 10;
2250 | 				}
2251 | 				consecutiveMoves++;
2252 | 				foolmateA++;
2253 | 				replayStore(rowA, col, desRowA, desCol);
2254 | 				turn = 'B';
2255 | 			}
2256 | 		}
2257 | 		else if (val[rowA][columnA] == 'B')
2258 | 		{
2259 | 			bool found = bishopForWhite(val, rowA, columnA, desRowA, desColumnA, opposite);
2260 | 			if (found == true) {
2261 | 				temp = val[desRowA][desColumnA];
2262 | 				val[desRowA][desColumnA] = val[rowA][columnA];
2263 | 				val[rowA][columnA] = ch;
2264 | 			}
2265 | 			found2 = afterCheck(val, rowA, columnA, desRowA, desColumnA, temp, opposite);
2266 | 			if (found == false || found2 == false)
2267 | 			{
2268 | 				cout << "\t\t\t\t\t ****************| Invalid Choice |*****************\n";
2269 | 				playerTurn(val, checkA, checkB, countAK, countAr_1, countAr_2, countBk, countBr_1, countBr_2);
2270 | 			}
2271 | 			else {
2272 | 				if (mode == 'R' || mode == 'r') {
2273 | 					rapidTimerA = rapidTimerA + 10;
2274 | 				}
2275 | 				consecutiveMoves++;
2276 | 				foolmateA++;
2277 | 				replayStore(rowA, col, desRowA, desCol);
2278 | 				turn = 'B';
2279 | 			}
2280 | 		}
2281 | 		else if (val[rowA][columnA] == 'Q')
2282 | 		{
2283 | 			bool found = queenForWhite(val, rowA, columnA, desRowA, desColumnA, opposite);
2284 | 			if (found == true) {
2285 | 				temp = val[desRowA][desColumnA];
2286 | 				val[desRowA][desColumnA] = val[rowA][columnA];
2287 | 				val[rowA][columnA] = ch;
2288 | 			}
2289 | 			found2 = afterCheck(val, rowA, columnA, desRowA, desColumnA, temp, opposite);
2290 | 			if (found == false || found2 == false)
2291 | 			{
2292 | 				cout << "\t\t\t\t\t ****************| Invalid Choice |*****************\n";
2293 | 				playerTurn(val, checkA, checkB, countAK, countAr_1, countAr_2, countBk, countBr_1, countBr_2);
2294 | 			}
2295 | 			else {
2296 | 				if (mode == 'R' || mode == 'r') {
2297 | 					rapidTimerA = rapidTimerA + 10;
2298 | 				}
2299 | 				consecutiveMoves++;
2300 | 				foolmateA++;
2301 | 				replayStore(rowA, col, desRowA, desCol);
2302 | 				turn = 'B';
2303 | 			}
2304 | 		}
2305 | 		else if (val[rowA][columnA] == 'K') {
2306 | 			bool found = castling(val, rowA, columnA, desRowA, desColumnA, opposite, countAK, countAr_1, countAr_2);
2307 | 			if (found == true)
2308 | 			{
2309 | 				checkDestination(opposite);
2310 | 				found = kingForWhite(val, rowA, columnA, desRowA, desColumnA, opposite);
2311 | 				if (found == true) {
2312 | 					temp = val[desRowA][desColumnA];
2313 | 					val[desRowA][desColumnA] = val[rowA][columnA];
2314 | 					val[rowA][columnA] = ch;
2315 | 				}
2316 | 				found2 = afterCheck(val, rowA, columnA, desRowA, desColumnA, temp, opposite);
2317 | 				if (found == false || found2 == false)
2318 | 				{
2319 | 					cout << "\t\t\t\t\t ****************| Invalid Choice |*****************\n";
2320 | 					playerTurn(val, checkA, checkB, countAK, countAr_1, countAr_2, countBk, countBr_1, countBr_2);
2321 | 				}
2322 | 				else {
2323 | 					if (mode == 'R' || mode == 'r') {
2324 | 						rapidTimerA = rapidTimerA + 10;
2325 | 					}
2326 | 					consecutiveMoves++;
2327 | 					foolmateA++;
2328 | 					replayStore(rowA, col, desRowA, desCol);
2329 | 					countAK++;
2330 | 					if (columnA == 0)
2331 | 						countAr_1++;
2332 | 					else if (columnA == 7)
2333 | 						countAr_2++;
2334 | 					turn = 'B';
2335 | 				}
2336 | 			}
2337 | 			else {
2338 | 				if (mode == 'R' || mode == 'r') {
2339 | 					rapidTimerA = rapidTimerA + 10;
2340 | 				}
2341 | 				consecutiveMoves++;
2342 | 				foolmateA++;
2343 | 				replayStore(rowA, col, desRowA, desCol);
2344 | 				countAK++;
2345 | 				if (columnA == 0)
2346 | 					countAr_1++;
2347 | 				else if (columnA == 7)
2348 | 					countAr_2++;
2349 | 				turn = 'B';
2350 | 			}
2351 | 		}
2352 | 		else {
2353 | 			cout << "\t\t\t\t\t ****************| Invalid Choice |*****************\n";
2354 | 			playerTurn(val, checkA, checkB, countAK, countAr_1, countAr_2, countBk, countBr_1, countBr_2);
2355 | 		}
2356 | 	}
2357 | 	else if (turn == 'B')
2358 | 	{
2359 | 		checkDestination(opposite);
2360 | 		if (val[rowB][columnB] == 'p')
2361 | 		{
2362 | 			temp = val[desRowB][desColumnB];
2363 | 			bool found = pawnForBlack(val, rowB, columnB, desRowB, desColumnB, opposite);
2364 | 			found2 = afterCheck(val, rowB, columnB, desRowB, desColumnB, temp, opposite);
2365 | 			if (found == false || found2 == false)
2366 | 			{
2367 | 				cout << "\t\t\t\t\t ****************| Invalid Choice |*****************\n";
2368 | 				playerTurn(val, checkA, checkB, countAK, countAr_1, countAr_2, countBk, countBr_1, countBr_2);
2369 | 			}
2370 | 			else {
2371 | 				if (mode == 'R' || mode == 'r') {
2372 | 					rapidTimerB = rapidTimerB + 10;
2373 | 				}
2374 | 				consecutiveMoves = 0;
2375 | 				foolmateB++;
2376 | 				replayStore(rowB, col, desRowB, desCol);
2377 | 				turn = 'A';
2378 | 			}
2379 | 		}
2380 | 		else if (val[rowB][columnB] == 'r')
2381 | 		{
2382 | 			checkDestination(opposite);
2383 | 			bool found = rookForWhite(val, rowB, columnB, desRowB, desColumnB, opposite);
2384 | 			if (found == true) {
2385 | 				temp = val[desRowB][desColumnB];
2386 | 				val[desRowB][desColumnB] = val[rowB][columnB];
2387 | 				val[rowB][columnB] = ch;
2388 | 			}
2389 | 			found2 = afterCheck(val, rowB, columnB, desRowB, desColumnB, temp, opposite);
2390 | 			if (found == false || found2 == false)
2391 | 			{
2392 | 				cout << "\t\t\t\t\t ****************| Invalid Choice |*****************\n";
2393 | 				playerTurn(val, checkA, checkB, countAK, countAr_1, countAr_2, countBk, countBr_1, countBr_2);
2394 | 			}
2395 | 			else {
2396 | 				if (mode == 'R' || mode == 'r') {
2397 | 					rapidTimerB = rapidTimerB + 10;
2398 | 				}
2399 | 				consecutiveMoves++;
2400 | 				foolmateB++;
2401 | 				replayStore(rowB, col, desRowB, desCol);
2402 | 				turn = 'A';
2403 | 			}
2404 | 		}
2405 | 		else if (val[rowB][columnB] == 'n')
2406 | 		{
2407 | 			bool found = knightForWhite(val, rowB, columnB, desRowB, desColumnB, opposite);
2408 | 			if (found == true) {
2409 | 				temp = val[desRowB][desColumnB];
2410 | 				val[desRowB][desColumnB] = val[rowB][columnB];
2411 | 				val[rowB][columnB] = ch;
2412 | 			}
2413 | 			found2 = afterCheck(val, rowB, columnB, desRowB, desColumnB, temp, opposite);
2414 | 			if (found == false || found2 == false)
2415 | 			{
2416 | 				cout << "\t\t\t\t\t ****************| Invalid Choice |*****************\n";
2417 | 				playerTurn(val, checkA, checkB, countAK, countAr_1, countAr_2, countBk, countBr_1, countBr_2);
2418 | 			}
2419 | 			else {
2420 | 				if (mode == 'R' || mode == 'r') {
2421 | 					rapidTimerB = rapidTimerB + 10;
2422 | 				}
2423 | 				consecutiveMoves++;
2424 | 				foolmateB++;
2425 | 				replayStore(rowB, col, desRowB, desCol);
2426 | 				turn = 'A';
2427 | 			}
2428 | 		}
2429 | 		else if (val[rowB][columnB] == 'b')
2430 | 		{
2431 | 			bool found = bishopForWhite(val, rowB, columnB, desRowB, desColumnB, opposite);
2432 | 			if (found == true) {
2433 | 				temp = val[desRowB][desColumnB];
2434 | 				val[desRowB][desColumnB] = val[rowB][columnB];
2435 | 				val[rowB][columnB] = ch;
2436 | 			}
2437 | 			found2 = afterCheck(val, rowB, columnB, desRowB, desColumnB, temp, opposite);
2438 | 			if (found == false || found2 == false)
2439 | 			{
2440 | 				cout << "\t\t\t\t\t ****************| Invalid Choice |*****************\n";
2441 | 				playerTurn(val, checkA, checkB, countAK, countAr_1, countAr_2, countBk, countBr_1, countBr_2);
2442 | 			}
2443 | 			else {
2444 | 				if (mode == 'R' || mode == 'r') {
2445 | 					rapidTimerB = rapidTimerB + 10;
2446 | 				}
2447 | 				consecutiveMoves++;
2448 | 				foolmateB++;
2449 | 				replayStore(rowB, col, desRowB, desCol);
2450 | 				turn = 'A';
2451 | 			}
2452 | 		}
2453 | 		else if (val[rowB][columnB] == 'q')
2454 | 		{
2455 | 			bool found = queenForWhite(val, rowB, columnB, desRowB, desColumnB, opposite);
2456 | 			if (found == true) {
2457 | 				temp = val[desRowB][desColumnB];
2458 | 				val[desRowB][desColumnB] = val[rowB][columnB];
2459 | 				val[rowB][columnB] = ch;
2460 | 			}
2461 | 			found2 = afterCheck(val, rowB, columnB, desRowB, desColumnB, temp, opposite);
2462 | 			if (found == false || found2 == false)
2463 | 			{
2464 | 				cout << "\t\t\t\t\t ****************| Invalid Choice |*****************\n";
2465 | 				playerTurn(val, checkA, checkB, countAK, countAr_1, countAr_2, countBk, countBr_1, countBr_2);
2466 | 			}
2467 | 			else {
2468 | 				if (mode == 'R' || mode == 'r') {
2469 | 					rapidTimerB = rapidTimerB + 10;
2470 | 				}
2471 | 				consecutiveMoves++;
2472 | 				foolmateB++;
2473 | 				replayStore(rowB, col, desRowB, desCol);
2474 | 				turn = 'A';
2475 | 			}
2476 | 		}
2477 | 		else if (val[rowB][columnB] == 'k')
2478 | 		{
2479 | 			bool found = castling(val, rowB, columnB, desRowB, desColumnB, opposite, countBk, countBr_1, countBr_2);
2480 | 			if (found == true) {
2481 | 				checkDestination(opposite);
2482 | 				found = kingForWhite(val, rowB, columnB, desRowB, desColumnB, opposite);
2483 | 				if (found == true) {
2484 | 					temp = val[desRowB][desColumnB];
2485 | 					val[desRowB][desColumnB] = val[rowB][columnB];
2486 | 					val[rowB][columnB] = ch;
2487 | 				}
2488 | 				found2 = afterCheck(val, rowB, columnB, desRowB, desColumnB, temp, opposite);
2489 | 				if (found == false || found2 == false)
2490 | 				{
2491 | 					cout << "\t\t\t\t\t ****************| Invalid Choice |*****************\n";
2492 | 					playerTurn(val, checkA, checkB, countAK, countAr_1, countAr_2, countBk, countBr_1, countBr_2);
2493 | 				}
2494 | 				else {
2495 | 					if (mode == 'R' || mode == 'r') {
2496 | 						rapidTimerB = rapidTimerB + 10;
2497 | 					}
2498 | 					consecutiveMoves++;
2499 | 					foolmateB++;
2500 | 					replayStore(rowB, col, desRowB, desCol);
2501 | 					countBk++;
2502 | 					if (columnB == 0)
2503 | 						countBr_1++;
2504 | 					else if (columnB == 7)
2505 | 						countBr_2++;
2506 | 					turn = 'A';
2507 | 				}
2508 | 			}
2509 | 			else {
2510 | 				if (mode == 'R' || mode == 'r') {
2511 | 					rapidTimerB = rapidTimerB + 10;
2512 | 				}
2513 | 				consecutiveMoves++;
2514 | 				foolmateB++;
2515 | 				replayStore(rowB, col, desRowB, desCol);
2516 | 				countBk++;
2517 | 				if (columnB == 0)
2518 | 					countBr_1++;
2519 | 				else if (columnB == 7)
2520 | 					countBr_2++;
2521 | 				turn = 'A';
2522 | 			}
2523 | 		}
2524 | 		else {
2525 | 			cout << "\t\t\t\t\t ****************| Invalid Choice |*****************\n";
2526 | 			playerTurn(val, checkA, checkB, countAK, countAr_1, countAr_2, countBk, countBr_1, countBr_2);
2527 | 		}
2528 | 	}
2529 | 	else
2530 | 	{
2531 | 		cout << "\t\t\t\t\t ****************| Invalid Choice |*****************\n";
2532 | 		playerTurn(val, checkA, checkB, countAK, countAr_1, countAr_2, countBk, countBr_1, countBr_2);
2533 | 	}
2534 | 
2535 | 	return 0;   //if there is no mate
2536 | }  // end of player Turn
2537 | 
2538 | int main() {
2539 | up:
2540 | 	system("cls");
2541 | 	char val[8][8] = {
2542 | 					   {'r','n','b','q','k','b','n','r'},
2543 | 					   {'p','p','p','p','p','p','p','p'},
2544 | 					   {' ',' ',' ',' ',' ',' ',' ',' '},
2545 | 					   {' ',' ',' ',' ',' ',' ',' ',' '},
2546 | 					   {' ',' ',' ',' ',' ',' ',' ',' '},
2547 | 					   {' ',' ',' ',' ',' ',' ',' ',' '},
2548 | 					   {'P','P','P','P','P','P','P','P'},
2549 | 					   {'R','N','B','Q','K','B','N','R'}
2550 | 	};
2551 | 	int n = 1;
2552 | 	int mate = 0;
2553 | 	
2554 | 	//counts for castling
2555 | 	int countAK = 1, countAr_1 = 1, countAr_2 = 1, countBk = 1, countBr_1 = 1, countBr_2 = 1;
2556 | 
2557 | 
2558 | 	//mode input
2559 | 	cout << "::ENTER C FOR CLASSICAL MODE::\n";
2560 | 	cout << "::ENTER R FOR RAPID MODE::\n";
2561 | 	cout << "::ENTER B FOR BLITZ MODE::\n";
2562 | 	cout << "::ENTER L FOR LIGHTENING MODE::\n";
2563 | 	cin >> mode;
2564 | 	
2565 | 	
2566 | 	if (mode == 'L' || mode == 'l' || mode == 'R' || mode == 'r' || mode == 'B' || mode == 'b' || mode == 'C' || mode == 'c')
2567 | 	{
2568 | 
2569 | 		//print board
2570 | 		//display(val);
2571 | 
2572 | 
2573 | 		//for classical Mode
2574 | 		while (mate == 0) {
2575 | 
2576 | 
2577 | 			//print board
2578 | 			display(val);
2579 | 
2580 | 			char srcRow, srcCol, desRow, desCol;
2581 | 			int row=9, column=9, destinationRow=9, desColumn=9;
2582 | 			char board[8][8] = {
2583 | 				   {'r','n','b','q','k','b','n','r'},
2584 | 				   {'p','p','p','p','p','p','p','p'},
2585 | 				   {' ',' ',' ',' ',' ',' ',' ',' '},
2586 | 				   {' ',' ',' ',' ',' ',' ',' ',' '},
2587 | 				   {' ',' ',' ',' ',' ',' ',' ',' '},
2588 | 				   {' ',' ',' ',' ',' ',' ',' ',' '},
2589 | 				   {'P','P','P','P','P','P','P','P'},
2590 | 				   {'R','N','B','Q','K','B','N','R'}
2591 | 			};
2592 | 
2593 | 
2594 | 			//input what user want
2595 | 			char savetype, dor;
2596 | 			cout << "::WHICH FILE DO YOU WANT TO OPEN::" << endl << endl;
2597 | 			cout << "::PRESS 0 FOR NEW GAME::" << endl;
2598 | 			cout << "::PRESS 1 FOR LOADING FILE 1::" << endl;
2599 | 			cout << "::PRESS 2 FOR LOADING FILE 2::" << endl;
2600 | 			cout << "::PRESS 3 LOADING FILE 3::" << endl;
2601 | 			cout << "::PRESS 4 TO CONTINUE::" << endl;
2602 | 			cout << "::PRESS S TO SAVE GAME::\n";
2603 | 			cin >> savetype;
2604 | 
2605 | 			//if user wants to load the saved games
2606 | 			if (savetype == '1' || savetype == '2' || savetype == '3') {
2607 | 				//counts for castling
2608 | 				cout << "::TO OPEN DIRECTLY PRESS 1::" << endl;
2609 | 				cout << "::TO SHOW REPLAY PRESS 2::" << endl;
2610 | 				cin >> dor;
2611 | 				Sleep(2000);
2612 | 				if (savetype == '1') {
2613 | 					display(board);
2614 | 					ifstream MyFile("save1.txt");
2615 | 					countAK = 1, countAr_1 = 1, countAr_2 = 1, countBk = 1, countBr_1 = 1, countBr_2 = 1;
2616 | 					while (!MyFile.eof()) {
2617 | 						MyFile >> srcCol >> srcRow >> desCol >> desRow;
2618 | 						int  column = SWITCH(srcCol);
2619 | 						int row = rowSwitch(srcRow);
2620 | 
2621 | 						int  desColumn = SWITCH(desCol);
2622 | 						int destinationRow = rowSwitch(desRow);
2623 | 						
2624 | 						if (MyFile.eof())
2625 | 							break;
2626 | 						
2627 | 						replaymove(board, row, column, destinationRow, desColumn);
2628 | 						system("cls");
2629 | 						
2630 | 						//if replay
2631 | 						if (dor == '2' && !_kbhit()) {
2632 | 							display(board);
2633 | 							Sleep(2000);
2634 | 						}
2635 | 						else
2636 | 							display(board);
2637 | 						if (turn == 'A')
2638 | 							turn = 'B';
2639 | 						else
2640 | 							turn = 'A';
2641 | 					}
2642 | 				}
2643 | 				else if (savetype == '2') {
2644 | 					display(board);
2645 | 					ifstream MyFile("save2.txt");
2646 | 					countAK = 1, countAr_1 = 1, countAr_2 = 1, countBk = 1, countBr_1 = 1, countBr_2 = 1;
2647 | 					while (!MyFile.eof()) {
2648 | 						MyFile >> srcCol >> srcRow >> desCol >> desRow;
2649 | 						int  column = SWITCH(srcCol);
2650 | 						int row = rowSwitch(srcRow);
2651 | 
2652 | 						int  desColumn = SWITCH(desCol);
2653 | 						int destinationRow = rowSwitch(desRow);
2654 | 
2655 | 						if (MyFile.eof())
2656 | 							break;
2657 | 
2658 | 						replaymove(board, row, column, destinationRow, desColumn);
2659 | 						system("cls");
2660 | 
2661 | 						//if replay
2662 | 						if (dor == '2' && !_kbhit()) {
2663 | 							display(board);
2664 | 							Sleep(2000);
2665 | 						}
2666 | 
2667 | 						else
2668 | 							display(board);
2669 | 						if (turn == 'A')
2670 | 							turn = 'B';
2671 | 						else
2672 | 							turn = 'A';
2673 | 					}
2674 | 				}
2675 | 				else if (savetype == '3') {
2676 | 					display(board);
2677 | 					ifstream MyFile("save3.txt");
2678 | 					countAK = 1, countAr_1 = 1, countAr_2 = 1, countBk = 1, countBr_1 = 1, countBr_2 = 1;
2679 | 					while (!MyFile.eof()) {
2680 | 						MyFile >> srcCol >> srcRow >> desCol >> desRow;
2681 | 						int  column = SWITCH(srcCol);
2682 | 						int row = rowSwitch(srcRow);
2683 | 
2684 | 						int  desColumn = SWITCH(desCol);
2685 | 						int destinationRow = rowSwitch(desRow);
2686 | 
2687 | 						if (MyFile.eof())
2688 | 							break;
2689 | 
2690 | 						replaymove(board, row, column, destinationRow, desColumn);
2691 | 						system("cls");
2692 | 
2693 | 						//if replay
2694 | 						if (dor == '2' && !_kbhit()) {
2695 | 							display(board);
2696 | 							Sleep(2000);
2697 | 						}
2698 | 						else
2699 | 							display(board);
2700 | 						if (turn == 'A')
2701 | 							turn = 'B';
2702 | 						else
2703 | 							turn = 'A';
2704 | 					}
2705 | 				}
2706 | 			}
2707 | 				else if (savetype == '0') {
2708 | 					goto up;
2709 | 			}
2710 | 				else if (savetype == 'S') {
2711 | 				cout << "::PRESS 1 TO SAVE IN FILE 1::\n";
2712 | 				cout << "::PRESS 2 TO SAVE IN FILE 2::\n";
2713 | 				cout << "::PRESS 3 TO SAVE IN FILE 3::\n";
2714 | 				cin >> fileChoice;
2715 | 				if(fileChoice=='1'){
2716 | 					ofstream saveFile1;
2717 | 					saveFile1.open("save1.txt");
2718 | 					int size = strlen(saveMoves);
2719 | 					for (int i = 0; i < size; i++) {
2720 | 						saveFile1 << saveMoves[i];
2721 | 					}
2722 | 				}
2723 | 				else if (fileChoice == '2') {
2724 | 					ofstream saveFile2;
2725 | 					saveFile2.open("save2.txt");
2726 | 					int size = strlen(saveMoves);
2727 | 					for (int i = 0; i < size; i++) {
2728 | 						saveFile2 << saveMoves[i];
2729 | 					}
2730 | 				}
2731 | 				if (fileChoice == '3') {
2732 | 					ofstream saveFile3;
2733 | 					saveFile3.open("save3.txt");
2734 | 					int size = strlen(saveMoves);
2735 | 					for (int i = 0; i < size; i++) {
2736 | 						saveFile3 << saveMoves[i];
2737 | 					}
2738 | 				}
2739 | 				}
2740 | 			if (savetype == '1' || savetype == '2' || savetype == '3') {
2741 | 				for (int i = 0; i < 8; i++) {
2742 | 					for (int j = 0; j < 8; j++) {
2743 | 						val[i][j] = board[i][j];
2744 | 					}
2745 | 				}
2746 | 			}
2747 | 
2748 | 			system("cls");
2749 | 			
2750 | 
2751 | 			//print board
2752 | 			display(val);
2753 | 
2754 | 
2755 | 			mate = playerTurn(val, checkA, checkB, countAK, countAr_1, countAr_2, countBk, countBr_1, countBr_2);
2756 | 			if (mate != 0)
2757 | 				break;
2758 | 			system("cls");
2759 | 
2760 | 		}//loop end
2761 | 
2762 | 	}// if end
2763 | 	
2764 | 	else
2765 | 		cout << "::INVALID INPUT::\n";
2766 | 	return 0;
2767 | }
2768 | 
2769 | 


--------------------------------------------------------------------------------