Chess

#include <iostream>
#include <windows.h>
#include <conio.h>
#include "Chess.h"
using namespace std;
char board[8][8] =
{
{ 'r', 'n', 'b', 'q', 'k', 'b', 'n', 'r' },
{ 'p', 'p', 'p', 'p', 'p', 'p', 'p', 'p' },
{ ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ' },
{ ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ' },
{ ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ' },
{ ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ' },
{ 'P', 'P', 'P', 'P', 'P', 'P', 'P', 'P' },
{ 'R', 'N', 'B', 'Q', 'K', 'B', 'N', 'R' },
};
//................. p=P=Pawn, r=R=Tower, n=N=Knight, q=Q=Queen,
k=K=King .................//
bool Player1PawnMove(int Frow, int Fcolumn, int Trow, int Tcolumn)
{
if (Frow == 6)
{
if (Frow - 1 == Trow && Fcolumn == Tcolumn)
{
if (board[Trow][Tcolumn] == ' ')
{
board[Frow][Fcolumn] = ' ';
board[Trow][Tcolumn] = 'P';
return true;
}
else
{
return false;
}
}

{
if ((board[Frow - 1][Fcolumn] == ' ') && (board[Trow][Tcolumn] ==
' '))
{
return true;
}
else
{
return false;
}
}
}
else
{
{
{
return true;
}
else
{
return false;
}
}
if (Frow - 1 == Trow && Fcolumn - 1 == Tcolumn)

{
if ((board[Trow][Tcolumn] != ' ') && (board[Trow][Tcolumn] !=
'R') && (board[Trow][Tcolumn] != 'N') && (board[Trow][Tcolumn] != 'B') &&
(board[Trow][Tcolumn] != 'Q') && (board[Trow][Tcolumn] != 'K') && (board[Trow]
[Tcolumn] != 'P'))
{
return true;
}
else
{
return false;
}
}
if (Frow - 1 == Trow && Fcolumn + 1 == Tcolumn)
{
if ((board[Trow][Tcolumn] != ' ') & (board[Trow][Tcolumn] != 'R')
&& (board[Trow][Tcolumn] != 'N') && (board[Trow][Tcolumn] != 'B') && (board[Trow]
[Tcolumn] != 'Q') && (board[Trow][Tcolumn] != 'K') && (board[Trow][Tcolumn] !=
'P'))
{
return true;
}
else
{
return false;
}
}
}
}
bool Player2PawnMove(int Frow, int Fcolumn, int Trow, int Tcolumn)
{
if (Frow == 1)
{
if (Frow + 1 == Trow&&Fcolumn == Tcolumn)
{
{
board[Trow][Tcolumn] = 'p';
return true;
}
else
{
return false;
}
}

{
if ((board[Frow + 1][Fcolumn] == ' ') && (board[Trow][Tcolumn] ==
' '))
{
return true;
}
else
{
return false;
}
}
}
else
{
{
{
return true;
}
else
{
return false;
}
}
if (Frow + 1 == Trow && Fcolumn - 1 == Tcolumn)
{
if ((board[Trow][Tcolumn] != ' ') & (board[Trow][Tcolumn] != 'r')
&& (board[Trow][Tcolumn] != 'n') && (board[Trow][Tcolumn] != 'b') && (board[Trow]
[Tcolumn] != 'q') && (board[Trow][Tcolumn] != 'k') && (board[Trow][Tcolumn] !=
'p'))
{
return true;
}
else
{
return false;
}
}
if (Frow + 1 == Trow && Fcolumn + 1 == Tcolumn)
{
if ((board[Trow][Tcolumn] != ' ') & (board[Trow][Tcolumn] != 'r')
&& (board[Trow][Tcolumn] != 'n') && (board[Trow][Tcolumn] != 'b') && (board[Trow]
[Tcolumn] != 'q') && (board[Trow][Tcolumn] != 'k') && (board[Trow][Tcolumn] !=
'p'))
{
return true;
}
else
{
return false;
}
}
}
}
bool Player1KnightMove(int Frow, int Fcolumn, int Trow, int Tcolumn)
{
{
if ((board[Trow][Tcolumn] != 'R') && (board[Trow][Tcolumn] != 'B') &&
[Tcolumn] != 'P') && (board[Trow][Tcolumn] != 'N'))
{
board[Trow][Tcolumn] = 'N';
return true;
}
else
{
return false;
}
}
else if (Frow - 2 == Trow&&Fcolumn - 1 == Tcolumn)
{
[Tcolumn] != 'P') && (board[Trow][Tcolumn] != 'N'))
{
return true;
}
else
return false;
}
else if (Frow - 1 == Trow&&Fcolumn + 2 == Tcolumn)
{
[Tcolumn] != 'N') && (board[Trow][Tcolumn] != 'P'))
{
return true;
}
else
return false;
}
{
(board[Trow][Tcolumn] != 'Q') && (board[Trow][Tcolumn] != 'N') && (board[Trow]
[Tcolumn] != 'K') && (board[Trow][Tcolumn] != 'P'))
{
return true;
}
else
return false;
}
else if (Frow + 1 == Trow&&Fcolumn + 2 == Tcolumn)
{
(board[Trow][Tcolumn] != 'N') && (board[Trow][Tcolumn] != 'Q') && (board[Trow]
{
return true;
}
else
return false;
}
else if (Frow + 1 == Trow&&Fcolumn - 2 == Tcolumn)
{
if ((board[Trow][Tcolumn] != 'R') && (board[Trow][Tcolumn] != 'N') &&
(board[Trow][Tcolumn] != 'B') && (board[Trow][Tcolumn] != 'Q') && (board[Trow]
{
return true;
}
else
return false;
}
{
if ((board[Trow][Tcolumn] != 'R') && (board[Trow][Tcolumn] != 'N') &&
(board[Trow][Tcolumn] != 'B') && (board[Trow][Tcolumn] != 'Q') && (board[Trow]
{
return true;
}
else
return false;
}
{
(board[Trow][Tcolumn] != 'N') && (board[Trow][Tcolumn] != 'Q') && (board[Trow]
{
return true;
}
else
return false;
}
}
bool Player2KnightMove(int Frow, int Fcolumn, int Trow, int Tcolumn)
{
{
if ((board[Trow][Tcolumn] != 'r') && (board[Trow][Tcolumn] != 'n') &&
(board[Trow][Tcolumn] != 'b') && (board[Trow][Tcolumn] != 'q') && (board[Trow]
[Tcolumn] != 'k') && (board[Trow][Tcolumn] != 'p'))
{
board[Trow][Tcolumn] = 'n';
return true;
}
else
{
return false;
}
}
{
{
return true;
}
else
return false;
}
else if (Frow - 1 == Trow&&Fcolumn + 2 == Tcolumn)
{
if ((board[Trow][Tcolumn] != 'r') && (board[Trow][Tcolumn] != 'b') &&
(board[Trow][Tcolumn] != 'n') && (board[Trow][Tcolumn] != 'q') && (board[Trow]
{
return true;
}
else
return false;
}
{
(board[Trow][Tcolumn] != 'q') && (board[Trow][Tcolumn] != 'n') && (board[Trow]
{
return true;
}
else
return false;
}
{
(board[Trow][Tcolumn] != 'q') && (board[Trow][Tcolumn] != 'k') && (board[Trow]
[Tcolumn] != 'n') && (board[Trow][Tcolumn] != 'p'))
{
return true;
}
else
return false;
}
{
[Tcolumn] != 'p') && (board[Trow][Tcolumn] != 'n'))
{
return true;
}
else
return false;
}
{
{
return true;
}
else
return false;
}
{
[Tcolumn] != 'n') && (board[Trow][Tcolumn] != 'p'))
{
return true;
}
else
return false;
}
}
bool Player1TowerMove(int Frow, int Fcolumn, int Trow, int Tcolumn)
{
if (Frow == Trow)
{
if (Tcolumn > Fcolumn)
{
for (int i = Fcolumn+1; i < Tcolumn; i++)
{
if ((board[i][Tcolumn] == 'R') || (board[i][Tcolumn] ==
'N') || (board[i][Tcolumn] == 'B') || (board[i][Tcolumn] == 'Q') || (board[i]
[Tcolumn] == 'K') || (board[i][Tcolumn] == 'P') || (board[i][Tcolumn] == 'r') ||
(board[i][Tcolumn] == 'n') || (board[i][Tcolumn] == 'b') || (board[i][Tcolumn] ==
'q') || (board[i][Tcolumn] == 'k') || (board[i][Tcolumn] == 'p'))
{
return false;
}
}
if ((board[Trow][Tcolumn] == 'R') || (board[Trow][Tcolumn] ==
'N') || (board[Trow][Tcolumn] == 'B') || (board[Trow][Tcolumn] == 'Q') ||
(board[Trow][Tcolumn] == 'K') || (board[Trow][Tcolumn] == 'P'))
{
return false;
}
board[Trow][Tcolumn] = 'R';
return true;
}
else if(Tcolumn<Fcolumn)
{
for (int i = Fcolumn-1; i > Tcolumn; i--)
{
{
return false;
}
}
{
return false;
}
return true;
}
}
if (Fcolumn == Tcolumn)
{
if (Trow > Frow)
{
for (int i = Frow + 1; i < Trow; i++)
{
{
return false;
}
}
{
return false;
}
return true;
}
else if(Trow<Frow)
{
for (int i = Frow-1; i > Trow; i--)
{
{
return false;
}
}
{
return false;
}
return true;
}
}
}
bool Player2TowerMove(int Frow, int Fcolumn, int Trow, int Tcolumn)
{
if (Frow == Trow)
{
{
for (int i = Fcolumn + 1; i < Tcolumn; i++)
{
if ((board[Trow][i] == 'R') || (board[Trow][i] == 'N') ||
(board[Trow][i] == 'B') || (board[Trow][i] == 'Q') || (board[Trow][i] == 'K') ||
(board[Trow][i] == 'P') || (board[Trow][i] == 'r') || (board[Trow][i] == 'n') ||
(board[Trow][i] == 'b') || (board[Trow][i] == 'q') || (board[Trow][i] == 'k') ||
(board[Trow][i] == 'p'))
{
return false;
}
if ((board[Trow][Tcolumn] == 'r') || (board[Trow][Tcolumn]
== 'n') || (board[Trow][Tcolumn] == 'b') || (board[Trow][Tcolumn] == 'q') ||
(board[Trow][Tcolumn] == 'k') || (board[Trow][Tcolumn] == 'p'))
{
return false;
}
}
board[Trow][Tcolumn] = 'r';
return true;
}
else if (Tcolumn<Fcolumn)
{
for (int i = Fcolumn - 1; i > Tcolumn; i--)
{
{
return false;
}
}
if ((board[Trow][Tcolumn] == 'r') || (board[Trow][Tcolumn] ==
'n') || (board[Trow][Tcolumn] == 'b') || (board[Trow][Tcolumn] == 'q') ||
{
return false;
}
return true;
}
}
{
if (Trow > Frow)
{
{
{
return false;
}
}
{
return false;
}
return true;
}
else if (Trow<Frow)
{
for (int i = Frow - 1; i > Trow; i--)
{
{
return false;
}
}
{
return false;
}
return true;
}
}
}
bool Player1BishipMove(int Frow, int Fcolumn, int Trow, int Tcolumn)

{
if (Frow < Trow&&Fcolumn < Tcolumn&&Trow == Tcolumn)
{
int j = Fcolumn + 1;
{
if ((board[i][j] == 'R') || (board[i][j] == 'N') || (board[i][j]
== 'B') || (board[i][j] == 'Q') || (board[i][j] == 'K') || (board[i][j] == 'P') ||
(board[i][j] == 'r') || (board[i][j] == 'n') || (board[i][j] == 'b') || (board[i]
[j] == 'q') || (board[i][j] == 'k') || (board[i][j] == 'p'))
{
return false;
}
j++;
}
if ((board[Trow][Tcolumn] == 'R') || (board[Trow][Tcolumn] == 'N') ||
(board[Trow][Tcolumn] == 'B') || (board[Trow][Tcolumn] == 'Q') || (board[Trow]
[Tcolumn] == 'K') || (board[Trow][Tcolumn] == 'P'))
{
return false;
}
board[Trow][Tcolumn] = 'B';
return true;
}
else if (Frow > Trow&&Fcolumn > Tcolumn&&Trow == Tcolumn)

{
int j = Fcolumn - 1;
for (int i = Frow-1; i > Trow; i--)
{
{
return false;
}
j--;
}
{
return false;
}
return true;
}
if(Frow > Trow&&Fcolumn < Tcolumn)
{
for (int i = Frow-1, j = Fcolumn + 1; i > Trow,j<Tcolumn; i--, j++)
{
== 'B') || (board[i][j] == 'Q') || (board[i][j] == 'K') || (board[i][j] == 'P')||
{
return false;
}
}
{
return false;
}
return true;
}
else if (Frow < Trow&&Fcolumn > Tcolumn)
{
for (int i = Frow+1,j = Fcolumn - 1; i < Trow,j>Tcolumn; i++,j--)
{
{
return false;
}
}
{
return false;
}
return true;
}
}
bool Player2BishipMove(int Frow, int Fcolumn, int Trow, int Tcolumn)
{
{
{
{
return false;
}
j++;
}
if ((board[Trow][Tcolumn] == 'r') || (board[Trow][Tcolumn] == 'n') ||
(board[Trow][Tcolumn] == 'b') || (board[Trow][Tcolumn] == 'q') || (board[Trow]
[Tcolumn] == 'k') || (board[Trow][Tcolumn] == 'p'))
{
return false;
}
board[Trow][Tcolumn] = 'b';
return true;
}

{
{
{
return false;
}
j--;
}
{
return false;
}
return true;
}
if (Frow > Trow&&Fcolumn < Tcolumn)
{
for (int i = Frow - 1, j = Fcolumn + 1; i > Trow, j<Tcolumn; i--, j++)
{
{
return false;
}
}
{
return false;
}
return true;
}
{
for (int i = Frow + 1, j = Fcolumn - 1; i < Trow, j > Tcolumn; i++,
j--)
{
{
return false;
}
}
{
return false;
}
return true;
}
}
bool Player1QueenMove(int Frow, int Fcolumn, int Trow, int Tcolumn)
{
if (Frow == Trow)
{
{
{
if ((board[Trow][i] == 'R') || (board[Trow][i] ==
'N') || (board[Trow][i] == 'B') || (board[Trow][i] == 'Q') || (board[Trow][i] ==
'K') || (board[Trow][i] == 'P') || (board[Trow][i] == 'r') || (board[Trow][i] ==
'n') || (board[Trow][i] == 'b') || (board[Trow][i] == 'q') || (board[Trow][i] ==
'k') || (board[Trow][i] == 'p'))
{
return false;
}
}
if ((board[Trow][Tcolumn] == 'R') || (board[Trow][Tcolumn]
== 'N') || (board[Trow][Tcolumn] == 'B') || (board[Trow][Tcolumn] == 'Q') ||
{
return false;
}
board[Trow][Tcolumn] = 'Q';
return true;
}
{
{
'N') || (board[Trow][i] == 'B') || (board[Trow][i] == 'Q') || (board[Trow][i] ==
'K') || (board[Trow][i] == 'P') || (board[Trow][i] == 'r') || (board[Trow][i] ==
'n') || (board[Trow][i] == 'b') || (board[Trow][i] == 'q') || (board[Trow][i] ==
'k') || (board[Trow][i] == 'p'))
{
return false;
}
}
{
return false;
}
return true;
}
}
{
if (Trow > Frow)
{
{
if ((board[i][Tcolumn] == 'R') || (board[i][Tcolumn]
== 'N') || (board[i][Tcolumn] == 'B') || (board[i][Tcolumn] == 'Q') || (board[i]
{
return false;
}
}
{
return false;
}
return true;
}
else if (Trow<Frow)
{
{
== 'N') || (board[i][Tcolumn] == 'B') || (board[i][Tcolumn] == 'Q') || (board[i]
{
return false;
}
}
{
return false;
}
return true;
}
}
//........................................diagnoal
move........................................//
{
{
if ((board[i][j] == 'R') || (board[i][j] == 'N') ||
(board[i][j] == 'B') || (board[i][j] == 'Q') || (board[i][j] == 'K') || (board[i]
[j] == 'P') || (board[i][j] == 'r') || (board[i][j] == 'n') || (board[i][j] == 'b')
|| (board[i][j] == 'q') || (board[i][j] == 'k') || (board[i][j] == 'p'))
{
return false;
}
j++;
}
{
return false;
}
return true;
}

{
int ;
for (int i = Frow - 1, j = Fcolumn - 1; i > Trow,j>Tcolumn;
i--,j--)
{
{
return false;
}
}
{
return false;
}
return true;
}
{
for (int i = Frow - 1, j = Fcolumn + 1; i > Trow, j<Tcolumn; i--,
j++)
{
{
return false;
}
}
{
return false;
}
return true;
}
{
for (int i = Frow + 1, j = Fcolumn - 1; i < Trow, j > Tcolumn; i+
+, j--)
{
{
return false;
}
}
{
return false;
}
return true;
}
}
bool Player2QueenMove(int Frow, int Fcolumn, int Trow, int Tcolumn)
{
if (Frow == Trow)
{
{
{
{
return false;
}
}
{
return false;
}
board[Trow][Tcolumn] = 'q';
return true;
}
{
{
{
return false;
}
}
{
return false;
}
return true;
}
}
{
if (Trow > Frow)
{
{
{
return false;
}
}
{
return false;
}
return true;
}
else if (Trow<Frow)
{
{
{
return false;
}
}
{
return false;
}
return true;
}
}
//........................................diagnoal
move........................................//
{
{
{
return false;
}
j++;
}
{
return false;
}
return true;
}

{
{
{
return false;
}
j--;
}
{
return false;
}
return true;
}
{
for (int i = Frow - 1, j = Fcolumn + 1; i > Trow, j<Tcolumn; i--, j++)
{
{
return false;
}
}
{
return false;
}
return true;
}
{
for (int i = Frow + 1, j = Fcolumn - 1; i < Trow, j > Tcolumn; i++,
j--)
{
{
return false;
}
}
{
return false;
}
return true;
}
}
bool Player1KingMove(int Frow, int Fcolumn, int Trow, int Tcolumn)
{
{
if ((Frow - 1 == Trow) && (Fcolumn == Tcolumn))
{
for (int i = Tcolumn; i >= 0; i--)
{
if (board[i][Tcolumn] != ' ')
{
== 'Q'))
{
return false;
}
else if (board[i][Tcolumn] == 'P' || board[i]
[Tcolumn] == 'B' || board[i][Tcolumn] == 'N' || board[i][Tcolumn] == 'p' ||
board[i][Tcolumn] == 'b' || board[i][Tcolumn] == 'n')
{
break;
}
}
}
for (int i = Tcolumn; i < 8; i++)
{
{
== 'Q'))
{
return false;
}
{
break;
}
}
}

{
{
'Q'))
{
return false;
}
else if (board[Trow][i] == 'P' || board[Trow][i] ==

'B' || board[Trow][i] == 'N' || board[Trow][i] == 'p' || board[Trow][i] == 'b' ||
board[Trow][i] == 'n')
{
break;
}
}
}
{
{
'Q'))
{
return false;
}
{
break;
}
}
}
//..................DIAGONAL
MOVE....................///////////////
int i = Trow;
for (int j = Tcolumn; j >= 0; j--)
{
if (board[i][j] != ' ')
{
if ((board[i][j] == 'B') || (board[i][j] == 'Q'))
{
return false;
}
else if (board[i][j] == 'P' || board[i][j] == 'R' ||
board[i][j] == 'N' || board[i][j] == 'r' || board[i][j] == 'p' || board[i][j] ==
'b' || board[i][j] == 'n')
{
break;
}
}
i--;
}
int c = Trow;
for (int j = Tcolumn; j <= 8; j++)
{
if (board[i][j] != ' ')
{
if ((board[c][j] == 'B') || (board[c][j] == 'Q'))
{
return false;
}
else if (board[c][j] == 'P' || board[c][j] == 'R' ||
board[c][j] == 'N' || board[c][j] == 'r' || board[c][j] == 'p' || board[c][j] ==
'b' || board[c][j] == 'n' || board[c][j] == 'q')
{
break;
}
}
c--;
}
int x = Trow;
{
if (board[x][j] != ' ')
{
if ((board[x][j] == 'B') || (board[x][j] == 'Q'))
{
return false;
}
else if (board[x][j] == 'P' || board[x][j] == 'R' ||
board[x][j] == 'N' || board[x][j] == 'r' || board[x][j] == 'p' || board[x][j] ==
'b' || board[x][j] == 'n' || board[x][j] == 'q')
{
break;
}
}
x++;
}
int z = Trow;
{
if (board[z][j] != ' ')
{
if ((board[z][j] == 'B') || (board[z][j] == 'Q'))
{
return false;
}
else if (board[z][j] == 'P' || board[z][j] == 'R' ||
board[z][j] == 'N' || board[z][j] == 'r' || board[z][j] == 'p' || board[z][j] ==
'b' || board[z][j] == 'n' || board[z][j] == 'q')
{
break;
}
}
z++;
}
board[Trow][Tcolumn] = 'K';
return true;
}
if ((Frow + 1 == Trow) && (Fcolumn == Tcolumn))

{
{
{
== 'Q'))
{
return false;
}
{
break;
}
}
}
{
{
== 'Q'))
{
return false;
}
{
break;
}
}
}

{
{
'Q'))
{
return false;
}

{
break;
}
}
}
{
{
'Q'))
{
return false;
}
{
break;
}
}
}
//..................DIAGONAL
MOVE....................///////////////
int i = Trow;
{
if (board[i][j] != ' ')
{
{
return false;
}
'b' || board[i][j] == 'n')
{
break;
}
}
i--;
}
int c = Trow;
{
if (board[i][j] != ' ')
{
{
return false;
}
{
break;
}
}
c--;
}
int x = Trow;
{
if (board[x][j] != ' ')
{
{
return false;
}
{
break;
}
}
x++;
}
int z = Trow;
{
if (board[z][j] != ' ')
{
{
return false;
}
{
break;
}
}
z++;
}
return true;
}
if ((Frow - 1 == Trow) && (Fcolumn - 1 == Tcolumn))

{
{
{
== 'Q'))
{
return false;
}
{
break;
}
}
}
{
{
== 'Q'))
{
return false;
}
{
break;
}
}
}

{
{
'Q'))
{
return false;
}

{
break;
}
}
}
{
{
'Q'))
{
return false;
}
{
break;
}
}
}
//..................DIAGONAL
MOVE....................///////////////
int i = Trow;
{
if (board[i][j] != ' ')
{
{
return false;
}
'b' || board[i][j] == 'n')
{
break;
}
}
i--;
}
int c = Trow;
{
if (board[i][j] != ' ')
{
{
return false;
}
{
break;
}
}
c--;
}
int x = Trow;
{
if (board[x][j] != ' ')
{
{
return false;
}
{
break;
}
}
x++;
}
int z = Trow;
{
if (board[z][j] != ' ')
{
{
return false;
}
{
break;
}
}
z++;
}
return true;
}
if ((Frow - 1 == Trow) && (Fcolumn + 1 == Tcolumn))

{
{
{
== 'Q'))
{
return false;
}
{
break;
}
}
}
{
{
== 'Q'))
{
return false;
}
{
break;
}
}
}

{
{
'Q'))
{
return false;
}

{
break;
}
}
}
{
{
'Q'))
{
return false;
}
{
break;
}
}
}
//..................DIAGONAL
MOVE....................///////////////
int i = Trow;
{
if (board[i][j] != ' ')
{
{
return false;
}
'b' || board[i][j] == 'n')
{
break;
}
}
i--;
}
int c = Trow;
{
if (board[i][j] != ' ')
{
{
return false;
}
{
break;
}
}
c--;
}
int x = Trow;
{
if (board[x][j] != ' ')
{
{
return false;
}
{
break;
}
}
x++;
}
int z = Trow;
{
if (board[z][j] != ' ')
{
{
return false;
}
{
break;
}
}
z++;
}
return true;
}
if ((Frow == Trow) && (Fcolumn - 1 == Tcolumn))

{
{
{
== 'Q'))
{
return false;
}
{
break;
}
}
}
{
{
== 'Q'))
{
return false;
}
{
break;
}
}
}

{
{
'Q'))
{
return false;
}

{
break;
}
}
}
{
{
'Q'))
{
return false;
}
{
break;
}
}
}
//..................DIAGONAL
MOVE....................///////////////
int i = Trow;
{
if (board[i][j] != ' ')
{
{
return false;
}
'b' || board[i][j] == 'n')
{
break;
}
}
i--;
}
int c = Trow;
{
if (board[i][j] != ' ')
{
{
return false;
}
{
break;
}
}
c--;
}
int x = Trow;
{
if (board[x][j] != ' ')
{
{
return false;
}
{
break;
}
}
x++;
}
int z = Trow;
{
if (board[z][j] != ' ')
{
{
return false;
}
{
break;
}
}
z++;
}
return true;
}
//..................................................................//
if ((Frow == Trow) && (Fcolumn + 1 == Tcolumn))

{
{
{
== 'Q'))
{
return false;
}
{
break;
}
}
}
{
{
== 'Q'))
{
return false;
}
{
break;
}
}
}
{
{
'Q'))
{
return false;
}

{
break;
}
}
}
{
{
'Q'))
{
return false;
}
{
break;
}
}
}
//..................DIAGONAL
MOVE....................///////////////
int i = Trow;
{
if (board[i][j] != ' ')
{
{
return false;
}
'b' || board[i][j] == 'n')
{
break;
}
}
i--;
}
int c = Trow;
{
if (board[i][j] != ' ')
{
{
return false;
}
{
break;
}
}
c--;
}
int x = Trow;
{
if (board[x][j] != ' ')
{
{
return false;
}
{
break;
}
}
x++;
}
int z = Trow;
{
if (board[z][j] != ' ')
{
{
return false;
}
{
break;
}
}
z++;
}
return true;
}
if ((Frow + 1 == Trow) && (Fcolumn + 1 == Tcolumn))

{
{
{
== 'Q'))
{
return false;
}
{
break;
}
}
}
{
{
== 'Q'))
{
return false;
}
{
break;
}
}
}

{
{
'Q'))
{
return false;
}

{
break;
}
}
}
{
{
'Q'))
{
return false;
}
{
break;
}
}
}
//..................DIAGONAL
MOVE....................///////////////
int i = Trow;
{
if (board[i][j] != ' ')
{
{
return false;
}
'b' || board[i][j] == 'n')
{
break;
}
}
i--;
}
int c = Trow;
{
if (board[i][j] != ' ')
{
{
return false;
}
{
break;
}
}
c--;
}
int x = Trow;
{
if (board[x][j] != ' ')
{
{
return false;
}
{
break;
}
}
x++;
}
int z = Trow;
{
if (board[z][j] != ' ')
{
{
return false;
}
{
break;
}
}
z++;
}
return true;
}
//.....................................................................
.............//
if ((Frow + 1 == Trow) && (Fcolumn - 1 == Tcolumn))
{
{
{
== 'Q'))
{
return false;
}
{
break;
}
}
}
{
{
== 'Q'))
{
return false;
}
{
break;
}
}
}

{
{
'Q'))
{
return false;
}

{
break;
}
}
}
{
{
'Q'))
{
return false;
}
{
break;
}
}
}
//..................DIAGONAL
MOVE....................///////////////
int i = Trow;
{
if (board[i][j] != ' ')
{
{
return false;
}
'b' || board[i][j] == 'n')
{
break;
}
}
i--;
}
int c = Trow;
{
if (board[i][j] != ' ')
{
{
return false;
}
{
break;
}
}
c--;
}
int x = Trow;
{
if (board[x][j] != ' ')
{
{
return false;
}
{
break;
}
}
x++;
}
int z = Trow;
{
if (board[z][j] != ' ')
{
{
return false;
}
{
break;
}
}
z++;
}
return true;
}
}
}
bool Player2KingMove(int Frow, int Fcolumn, int Trow, int Tcolumn)
{
{
if ((Frow - 1 == Trow) && (Fcolumn == Tcolumn))
{
{
{
== 'Q'))
{
return false;
}
{
break;
}
}
}
{
{
== 'Q'))
{
return false;
}
{
break;
}
}
}

{
{
'Q'))
{
return false;
}

{
break;
}
}
}
{
{
'Q'))
{
return false;
}
{
break;
}
}
}
//..................DIAGONAL
MOVE....................///////////////
int i = Trow;
{
if (board[i][j] != ' ')
{
{
return false;
}
'b' || board[i][j] == 'n')
{
break;
}
}
i--;
}
int c = Trow;
{
if (board[i][j] != ' ')
{
{
return false;
}
{
break;
}
}
c--;
}
int x = Trow;
{
if (board[x][j] != ' ')
{
{
return false;
}
{
break;
}
}
x++;
}
int z = Trow;
{
if (board[z][j] != ' ')
{
{
return false;
}
{
break;
}
}
z++;
}
board[Trow][Tcolumn] = 'k';
return true;
}
if ((Frow + 1 == Trow) && (Fcolumn == Tcolumn))

{
{
{
== 'Q'))
{
return false;
}
{
break;
}
}
}
{
{
== 'Q'))
{
return false;
}
{
break;
}
}
}

{
{
'Q'))
{
return false;
}

{
break;
}
}
}
{
{
'Q'))
{
return false;
}
{
break;
}
}
}
//..................DIAGONAL
MOVE....................///////////////
int i = Trow;
{
if (board[i][j] != ' ')
{
{
return false;
}
'b' || board[i][j] == 'n')
{
break;
}
}
i--;
}
int c = Trow;
{
if (board[i][j] != ' ')
{
{
return false;
}
{
break;
}
}
c--;
}
int x = Trow;
{
if (board[x][j] != ' ')
{
{
return false;
}
{
break;
}
}
x++;
}
int z = Trow;
{
if (board[z][j] != ' ')
{
{
return false;
}
{
break;
}
}
z++;
}
return true;
}
if ((Frow - 1 == Trow) && (Fcolumn - 1 == Tcolumn))

{
{
{
== 'Q'))
{
return false;
}
{
break;
}
}
}
{
{
== 'Q'))
{
return false;
}
{
break;
}
}
}

{
{
'Q'))
{
return false;
}

{
break;
}
}
}
{
{
'Q'))
{
return false;
}
{
break;
}
}
}
//..................DIAGONAL
MOVE....................///////////////
int i = Trow;
{
if (board[i][j] != ' ')
{
{
return false;
}
'b' || board[i][j] == 'n')
{
break;
}
}
i--;
}
int c = Trow;
{
if (board[i][j] != ' ')
{
{
return false;
}
{
break;
}
}
c--;
}
int x = Trow;
{
if (board[x][j] != ' ')
{
{
return false;
}
{
break;
}
}
x++;
}
int z = Trow;
{
if (board[z][j] != ' ')
{
{
return false;
}
{
break;
}
}
z++;
}
return true;
}
if ((Frow - 1 == Trow) && (Fcolumn + 1 == Tcolumn))

{
{
{
== 'Q'))
{
return false;
}
{
break;
}
}
}
{
{
== 'Q'))
{
return false;
}
{
break;
}
}
}

{
{
'Q'))
{
return false;
}

{
break;
}
}
}
{
{
'Q'))
{
return false;
}
{
break;
}
}
}
//..................DIAGONAL
MOVE....................///////////////
int i = Trow;
{
if (board[i][j] != ' ')
{
{
return false;
}
'b' || board[i][j] == 'n')
{
break;
}
}
i--;
}
int c = Trow;
{
if (board[i][j] != ' ')
{
{
return false;
}
{
break;
}
}
c--;
}
int x = Trow;
{
if (board[x][j] != ' ')
{
{
return false;
}
{
break;
}
}
x++;
}
int z = Trow;
{
if (board[z][j] != ' ')
{
{
return false;
}
{
break;
}
}
z++;
}
return true;
}
if ((Frow == Trow) && (Fcolumn - 1 == Tcolumn))

{
{
{
== 'Q'))
{
return false;
}
{
break;
}
}
}
{
{
== 'Q'))
{
return false;
}
{
break;
}
}
}

{
{
'Q'))
{
return false;
}

{
break;
}
}
}
{
{
'Q'))
{
return false;
}
{
break;
}
}
}
//..................DIAGONAL
MOVE....................///////////////
int i = Trow;
{
if (board[i][j] != ' ')
{
{
return false;
}
'b' || board[i][j] == 'n')
{
break;
}
}
i--;
}
int c = Trow;
{
if (board[i][j] != ' ')
{
{
return false;
}
{
break;
}
}
c--;
}
int x = Trow;
{
if (board[x][j] != ' ')
{
{
return false;
}
{
break;
}
}
x++;
}
int z = Trow;
{
if (board[z][j] != ' ')
{
{
return false;
}
{
break;
}
}
z++;
}
return true;
}
//..................................................................//
if ((Frow == Trow) && (Fcolumn + 1 == Tcolumn))

{
{
{
== 'Q'))
{
return false;
}
{
break;
}
}
}
{
{
== 'Q'))
{
return false;
}
{
break;
}
}
}

{
{
'Q'))
{
return false;
}

{
break;
}
}
}
{
{
'Q'))
{
return false;
}
{
break;
}
}
}
//..................DIAGONAL
MOVE....................///////////////
int i = Trow;
{
if (board[i][j] != ' ')
{
{
return false;
}
'b' || board[i][j] == 'n')
{
break;
}
}
i--;
}
int c = Trow;
{
if (board[i][j] != ' ')
{
{
return false;
}
{
break;
}
}
c--;
}
int x = Trow;
{
if (board[x][j] != ' ')
{
{
return false;
}
{
break;
}
}
x++;
}
int z = Trow;
{
if (board[z][j] != ' ')
{
{
return false;
}
{
break;
}
}
z++;
}
return true;
}
if ((Frow + 1 == Trow) && (Fcolumn + 1 == Tcolumn))

{
{
{
== 'Q'))
{
return false;
}
{
break;
}
}
}
{
{
== 'Q'))
{
return false;
}
{
break;
}
}
}

{
{
'Q'))
{
return false;
}

{
break;
}
}
}
{
{
'Q'))
{
return false;
}
{
break;
}
}
}
//..................DIAGONAL
MOVE....................///////////////
int i = Trow;
{
if (board[i][j] != ' ')
{
{
return false;
}
'b' || board[i][j] == 'n')
{
break;
}
}
i--;
}
int c = Trow;
{
if (board[i][j] != ' ')
{
{
return false;
}
{
break;
}
}
c--;
}
int x = Trow;
{
if (board[x][j] != ' ')
{
{
return false;
}
{
break;
}
}
x++;
}
int z = Trow;
{
if (board[z][j] != ' ')
{
{
return false;
}
{
break;
}
}
z++;
}
return true;
}
//.....................................................................
.............//
if ((Frow + 1 == Trow) && (Fcolumn - 1 == Tcolumn))
{
{
{
== 'Q'))
{
return false;
}
{
break;
}
}
}
{
{
== 'Q'))
{
return false;
}
{
break;
}
}
}

{
{
'Q'))
{
return false;
}

{
break;
}
}
}
{
{
'Q'))
{
return false;
}
{
break;
}
}
}
//..................DIAGONAL
MOVE....................///////////////
int i = Trow;
{
if (board[i][j] != ' ')
{
{
return false;
}
'b' || board[i][j] == 'n')
{
break;
}
}
i--;
}
int c = Trow;
{
if (board[i][j] != ' ')
{
{
return false;
}
{
break;
}
}
c--;
}
int x = Trow;
{
if (board[x][j] != ' ')
{
{
return false;
}
{
break;
}
}
x++;
}
int z = Trow;
{
if (board[z][j] != ' ')
{
{
return false;
}
{
break;
}
}
z++;
}
return true;
}
}
}
bool MoveItem(int Frow, int Fcolumn, int Trow, int Tcolumn)

{
//check if move is valid//
//check if move kills other player's piece//
switch (board[Frow][Fcolumn])
{
case 'P':
{
return Player1PawnMove(Frow, Fcolumn, Trow, Tcolumn);
break;
}
case 'p':
{
return Player2PawnMove(Frow, Fcolumn, Trow, Tcolumn);
break;
}
case 'R':
{
return Player1TowerMove(Frow, Fcolumn, Trow, Tcolumn);
break;
}
case 'r':
{
return Player2TowerMove(Frow, Fcolumn, Trow, Tcolumn);
break;
}
case 'N':
{
return Player1KnightMove(Frow, Fcolumn, Trow, Tcolumn);
break;
}
case 'n':
{
return Player2KnightMove(Frow, Fcolumn, Trow, Tcolumn);
break;
}
case 'B':
{
return Player1BishipMove(Frow, Fcolumn, Trow, Tcolumn);
break;
}
case 'b':
{
return Player2BishipMove(Frow, Fcolumn, Trow, Tcolumn);
break;
}
case 'Q':
{
return Player1QueenMove(Frow, Fcolumn, Trow, Tcolumn);
break;
}
case'q':
{
return Player2QueenMove(Frow, Fcolumn, Trow, Tcolumn);
break;
}
case 'K':
{
return Player1KingMove(Frow, Fcolumn, Trow, Tcolumn);
break;
}
case 'k':
{
return Player2KingMove(Frow, Fcolumn, Trow, Tcolumn);
break;
}
}
return false;
//return true if successfull. else false//
}
void PrintChessboard()
{
int GameOver;
int column = 0;
cout << "| 1 | 2| 3| 4| 5| 6| 7| 8| C" << endl;
cout << " R" << endl;
for (int i = 0; i<8; i++)
{
cout << "| ";
for (int j = 0; j<8; j++)
{
cout << board[i][j] << " |";
}
cout <<" "<< ++column;
cout << endl;
cout << "--------------------------" << endl;
}
}
int main()
{
cout << "Enter * to End" << endl;
while (1 == 1)
{
int Frow = 0, Fcolumn = 0, Trow = 0, Tcolumn = 0;
do
{
PrintChessboard();
cout << "Player 1 Move :" << endl;
cout << "Enter Row to Move from ";
cin >> Frow;
cout << "Enter Column to Move from ";
cin >> Fcolumn;
cout << "Item at Location: [" << Frow << "][" << Fcolumn << "] :"
<< board[Frow - 1][Fcolumn - 1] << endl;
cout << "Enter Row to Move to ";
cin >> Trow;
cout << "Enter Column to Move to ";
cin >> Tcolumn;
} while (MoveItem(Frow - 1, Fcolumn - 1, Trow - 1, Tcolumn - 1) !=

TRUE);
int Frow2 = 0, Fcolumn2 = 0, Trow2 = 0, Tcolumn2 = 0;
do
{
PrintChessboard();
cout << "Player 2 Move :" << endl;
cout << "Enter Row to Move from ";
cin >> Frow2;
cout << "Enter Column to Move from ";
cin >> Fcolumn2;
cout << "Item at Location: [" << Frow2 << "][" << Fcolumn2 <<
"] :" << board[Frow2 - 1][Fcolumn2 - 1] << endl;
cout << "Enter Row to Move to ";
cin >> Trow2;
cout << "Enter Column to Move to ";
cin >> Tcolumn2;
} while (MoveItem(Frow2 - 1, Fcolumn2 - 1, Trow2 - 1, Tcolumn2 - 1) !=
TRUE);
}
return 0;
}

Chess

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Chess

Uploaded by

Copyright:

Available Formats

#include <iostream>

using namespace std;

if (Frow - 2 == Trow && Fcolumn == Tcolumn)

if (Frow - 1 == Trow && Fcolumn - 1 == Tcolumn)

if (Frow + 2 == Trow&&Fcolumn == Tcolumn)

bool Player1BishipMove(int Frow, int Fcolumn, int Trow, int Tcolumn)

else if (Frow > Trow&&Fcolumn > Tcolumn&&Trow == Tcolumn)

else if (Frow > Trow&&Fcolumn > Tcolumn&&Trow == Tcolumn)

else if (Frow > Trow&&Fcolumn > Tcolumn&&Trow == Tcolumn)

else if (Frow > Trow&&Fcolumn > Tcolumn&&Trow == Tcolumn)

for (int i = Tcolumn; i >= 0; i--)

else if (board[Trow][i] == 'P' || board[Trow][i] ==

if ((Frow + 1 == Trow) && (Fcolumn == Tcolumn))

for (int i = Tcolumn; i >= 0; i--)

else if (board[Trow][i] == 'P' || board[Trow][i] ==

if ((Frow - 1 == Trow) && (Fcolumn - 1 == Tcolumn))

for (int i = Tcolumn; i >= 0; i--)

else if (board[Trow][i] == 'P' || board[Trow][i] ==

if ((Frow - 1 == Trow) && (Fcolumn + 1 == Tcolumn))

for (int i = Tcolumn; i >= 0; i--)

else if (board[Trow][i] == 'P' || board[Trow][i] ==

if ((Frow == Trow) && (Fcolumn - 1 == Tcolumn))

for (int i = Tcolumn; i >= 0; i--)

else if (board[Trow][i] == 'P' || board[Trow][i] ==

if ((Frow == Trow) && (Fcolumn + 1 == Tcolumn))

else if (board[Trow][i] == 'P' || board[Trow][i] ==

if ((Frow + 1 == Trow) && (Fcolumn + 1 == Tcolumn))

for (int i = Tcolumn; i >= 0; i--)

else if (board[Trow][i] == 'P' || board[Trow][i] ==

for (int i = Tcolumn; i >= 0; i--)

else if (board[Trow][i] == 'P' || board[Trow][i] ==

for (int i = Tcolumn; i >= 0; i--)

else if (board[Trow][i] == 'P' || board[Trow][i] ==

if ((Frow + 1 == Trow) && (Fcolumn == Tcolumn))

for (int i = Tcolumn; i >= 0; i--)

else if (board[Trow][i] == 'P' || board[Trow][i] ==

if ((Frow - 1 == Trow) && (Fcolumn - 1 == Tcolumn))

for (int i = Tcolumn; i >= 0; i--)

else if (board[Trow][i] == 'P' || board[Trow][i] ==

if ((Frow - 1 == Trow) && (Fcolumn + 1 == Tcolumn))

for (int i = Tcolumn; i >= 0; i--)

else if (board[Trow][i] == 'P' || board[Trow][i] ==

if ((Frow == Trow) && (Fcolumn - 1 == Tcolumn))

for (int i = Tcolumn; i >= 0; i--)

else if (board[Trow][i] == 'P' || board[Trow][i] ==

if ((Frow == Trow) && (Fcolumn + 1 == Tcolumn))

for (int i = Tcolumn; i >= 0; i--)

else if (board[Trow][i] == 'P' || board[Trow][i] ==

if ((Frow + 1 == Trow) && (Fcolumn + 1 == Tcolumn))

for (int i = Tcolumn; i >= 0; i--)

else if (board[Trow][i] == 'P' || board[Trow][i] ==

for (int i = Tcolumn; i >= 0; i--)

else if (board[Trow][i] == 'P' || board[Trow][i] ==

bool MoveItem(int Frow, int Fcolumn, int Trow, int Tcolumn)

} while (MoveItem(Frow - 1, Fcolumn - 1, Trow - 1, Tcolumn - 1) !=

You might also like