import javax.swing.JOptionPane;
import java.util.*;
import java.io.*;
import java.awt.*;
/*
 * Writen By : Ahmad Jawed ZAFAR
 * Date : 10/02/2009
 * */
public class Chess 
{
	public String GameBoard[][];
	public char sign1, sign2;
	public int maxLineLength;
	public String pA[];
	public String pB[];
	public String horseA[];
	public String elephantA[];
	public String king1;
	public String Queen1;
	public String rockA[];
	
	public String horseB[];
	public String elephantB[];
	public String king2;
	public String Queen2;
	public String rockB[];
	public String currentPlayer;
	public boolean checkForMatt;

	
	public Chess()
	{
		checkForMatt = false;
		king1 = "K1";
		king2 = "K2";
		
		horseA = horseB = new String[2];
		elephantA = elephantB = new String[2];
		rockA = rockB = new String[2];
		
		for (int j=0; j<2; j++)
		{
			horseA[j] = "H1";
			horseB[j] = "H2";
			elephantA[j] = "B1";
			elephantB[j] = "B2";
			rockA[j] = "R1";
			rockB[j] = "R2";	
		}
		
		pA = new String[8];
		pB = new String[8];
		
		for (int i=0; i<8; i++)
		{
			pA[i] = "P" + 1;
			pB[i] = "P" + 2;
		}
		
		maxLineLength = 4;
		GameBoard = new String[8][8];
	}
	public void initializeBoard()
	{
		checkForMatt = false;
		for (int i=0; i<8; i++)
		{
			for (int j=0; j<8; j++)
			{
				GameBoard[i][j] = "  ";
				if (i == 1)
				{
					GameBoard[i][j] = pB[j];
				}
				if (i == 6)
				{
					GameBoard[i][j] = pA[j];
				}
			}
		}
		
		GameBoard[0][2] = GameBoard[0][5] = "B2";
		GameBoard[7][2] = GameBoard[7][5] = "B1";
		
		GameBoard[0][1] = GameBoard[0][6] = "H2";
		GameBoard[7][1] = GameBoard[7][6] = "H1";
		
		GameBoard[0][0] = GameBoard[0][7] = "R2";
		GameBoard[7][0] = GameBoard[7][7] = "R1";
		
		GameBoard[0][3] = "Q2";
		GameBoard[0][4] = "K2";
		
		GameBoard[7][3] = "Q1";
		GameBoard[7][4] = "K1";
			
	}
	public void printBoard()
	{
		System.out.println("   --1--+--2--+--3--+--4--+--5--+--6--+--7--+--8--+");
		System.out.println("  +-----+-----+-----+-----+-----+-----+-----+-----+");
		for (int i=0; i<8; i++)
		{
			System.out.print(i+1 + "-| ");
			for (int j=0; j<8; j++)
			{
				System.out.print(" " + GameBoard[i][j] + " | ");
			}
			System.out.println();
			if (i==3)
			{
				System.out.println("  *************************************************");
			}
			else
			{
				System.out.println("  +-----+-----+-----+-----+-----+-----+-----+-----+");
			}
		}
	}
	public boolean checkWinner()
	{
		int checkForKing =0 ;
		
		for (int i=0; i<8; i++)
		{
			for (int j=0; j<8; j++)
			{
				if (GameBoard[i][j].equalsIgnoreCase("K1") || GameBoard[i][j].equalsIgnoreCase("K2"))
				{
					checkForKing++;
				}
			}
		}
		if (checkForKing < 2)
		{
			return true;
		}
		return false;
	}
	
	public boolean ifPawn(int xCur, int yCur, int xNex, int yNex) // if the item is a pion //
	{
		String tmp;
		
		if (GameBoard[yCur][xCur].substring(1).equalsIgnoreCase(GameBoard[yNex][xNex].substring(1)))
		{
			System.out.println("Friendly Fight Is Not Allowed");
			return false;
		}
		
			if (xCur == xNex) // moving upward for A1 or downward for A2 (location must be empty) ////////
			{
				if (currentPlayer.equalsIgnoreCase("1")) // check for valid move for player 1 //
				{
					if ((yCur - yNex) == 1 && GameBoard[yNex][xNex].equalsIgnoreCase("  "))
					{
						tmp = GameBoard[yCur][xCur];
						GameBoard[yNex][xNex] = tmp;
						GameBoard[yCur][xCur] = "  ";
						return true;
					}
					else {return false;}
				}
				else if (currentPlayer.equalsIgnoreCase("2")) // check for valid move for player 2 //
				{
					if ((yCur - yNex) == -1 && GameBoard[yNex][xNex].equalsIgnoreCase("  "))
					{
						tmp = GameBoard[yCur][xCur];
						GameBoard[yNex][xNex] = tmp;
						GameBoard[yCur][xCur] = "  ";
						return true;
					}
					else {return false;}
				}
			} // end of movint to an empty cell ///
			
			else // moving for fight //
			{
				if (GameBoard[yNex][xNex].equalsIgnoreCase("  ")) // cell must not be empty //
				{
					return false;
				}
				else
				{
					if (currentPlayer.equalsIgnoreCase("1")) // if current player is player 1 //
					{
						if (((xCur - xNex) == -1 && (yCur - yNex) == 1) || ((xCur - xNex) == 1 && (yCur - yNex) == 1))
						{
							tmp = GameBoard[yCur][xCur];
							GameBoard[yNex][xNex] = tmp;
							GameBoard[yCur][xCur] = "  ";
							return true;
						}
						else {return false;}
					}
					else if (currentPlayer.equalsIgnoreCase("2")) // if current player is player  //
					{
						if (((xCur - xNex) == -1 && (yCur - yNex) == -1) || ((xCur - xNex) == 1 && (yCur - yNex) == -1))
						{
							tmp = GameBoard[yCur][xCur];
							GameBoard[yNex][xNex] = tmp;
							GameBoard[yCur][xCur] = "  ";
							return true;
						}
						else {return false;}
					}
				}
		}
		return false;
}
	////////////// end if item is a pion ////////////////////////
	//********************************************************** //
	///////////////// begin if the item is a Rock ////////////////
	public boolean ifRook(int xCur, int yCur, int xNex, int yNex)
	{
		String tmp;
		
		if (GameBoard[yCur][xCur].substring(1).equalsIgnoreCase(GameBoard[yNex][xNex].substring(1)))
		{
			System.out.println("Friendly Fight Is Not Allowed");
			return false;
		}
		
		if (xCur == xNex && yCur != yNex) // moving vertically begin //
		{
				if (yCur > yNex) // moving vertically upward //
				{
					for (int i=yNex+1; i<yCur; i++)
					{
						if (!GameBoard[i][xCur].equalsIgnoreCase("  "))
						{
							return false;
						}
					}
					tmp = GameBoard[yCur][xCur];
					GameBoard[yNex][xNex] = tmp;
					GameBoard[yCur][xCur] = "  ";
					return true;
				}
				else if (yCur < yNex) // moving vertically downward //
				{
					for (int i=yCur+1; i<yNex; i++)
					{
						if (!GameBoard[i][xCur].equalsIgnoreCase("  "))
						{
							return false;
						}
					}
					tmp = GameBoard[yCur][xCur];
					GameBoard[yNex][xNex] = tmp;
					GameBoard[yCur][xCur] = "  ";
					return true;
				}
		} // moving vertically end //
		
		else if (yCur == yNex && xCur != xNex) // moving horizontally begin //
		{
				if (xCur < xNex) // moving horizontally right //
				{
					for (int i=xCur+1; i<xNex; i++)
					{
						if (!GameBoard[yCur][i].equalsIgnoreCase("  "))
						{
							return false;
						}
					}
					tmp = GameBoard[yCur][xCur];
					GameBoard[yNex][xNex] = tmp;
					GameBoard[yCur][xCur] = "  ";
					return true;
				}
				else if (xCur > xNex) // moving horizontally left //
				{
					for (int i=xNex+1; i<xCur; i++)
					{
						if (!GameBoard[yCur][i].equalsIgnoreCase("  "))
						{
							return false;
						}
					}
					tmp = GameBoard[yCur][xCur];
					GameBoard[yNex][xNex] = tmp;
					GameBoard[yCur][xCur] = "  ";
					return true;
				}
		} // moving horizontally end //
				
		else {return false;} // invalid move;
		
		return false;
	}
////////////////end if item is a Rook //////////////////////
	//********************************************************** //
	/////////////////// begin if item is an Bishop ////////////////
	public boolean ifBishop(int xCur, int yCur, int xNex, int yNex)
	{
		String tmp; // web set four for loops to check for cross moves //
		
		if (GameBoard[yCur][xCur].substring(1).equalsIgnoreCase(GameBoard[yNex][xNex].substring(1)))
		{
			System.out.println("Friendly Fight Is Not Allowed");
			return false;
		}
		
		if (xCur > xNex && yCur > yNex && (xCur - xNex) == (yCur - yNex)) // moving to the north west // 
		{
			
			int count=1;
			for (int i=yNex+1; i<yCur; i++) // check only the middle //
			{
				if (!GameBoard[yNex+count][xNex+count].equalsIgnoreCase("  "))
				{
					return false;
				}
				count++;
			}
			tmp = GameBoard[yCur][xCur];
			GameBoard[yNex][xNex] = tmp;
			GameBoard[yCur][xCur] = "  ";
			return true;
		}// end moving north west //
		
		else if (((xCur < xNex) && (yCur < yNex)) && (xCur - xNex) == (yCur - yNex)) // moving to the south east // 
		{
			int count=1;
			for (int i=yCur+1; i<yNex; i++) // check only the middle //
			{
				if (!GameBoard[i][xCur+count].equalsIgnoreCase("  "))
				{
					return false;
				}
				count++;
			}
			tmp = GameBoard[yCur][xCur];
			GameBoard[yNex][xNex] = tmp;
			GameBoard[yCur][xCur] = "  ";
			return true;
		}// end moving north west //
		
		else if (((xCur < xNex) && (yCur > yNex)) && (xCur - xNex) == (yNex - yCur)) // moving to the north east // 
		{
			int count=1;
			for (int i=yNex+1; i<yCur; i++) // check only the middle //
			{
				if (!GameBoard[i][xNex-count].equalsIgnoreCase("  "))
				{
					return false;
				}
				count++;
			}
			tmp = GameBoard[yCur][xCur];
			GameBoard[yNex][xNex] = tmp;
			GameBoard[yCur][xCur] = "  ";
			return true;
		}// end moving north west //
		
		else if (((xCur > xNex) && (yCur < yNex)) && (xCur - xNex) == (yNex - yCur)) // moving to the south west // 
		{
			int count=1;
			for (int i=yCur+1; i<yNex; i++) // check only the middle //
			{
				if (!GameBoard[i][xCur-count].equalsIgnoreCase("  "))
				{
					return false;
				}
				count++;
			}
			tmp = GameBoard[yCur][xCur];
			GameBoard[yNex][xNex] = tmp;
			GameBoard[yCur][xCur] = "  ";
			return true;
		}// end moving north west //
		
		return false;
	}
	
	///////////////// end if item is an Bishop ///////////////////
	//********************************************************** //
	
	////////////////////// begin if item is a Knight ///////////////
	public boolean ifKnight(int xCur, int yCur, int xNex, int yNex)
	{
		String tmp;
		
		if (GameBoard[yCur][xCur].substring(1).equalsIgnoreCase(GameBoard[yNex][xNex].substring(1)))
		{
			System.out.println("Friendly Fight Is Not Allowed");
			return false;
		}
		
		if (((xCur - xNex) == 1 && (yCur - yNex) == 2) || ((xCur - xNex) == -1 && (yCur - yNex) == 2) || 
				((xCur - xNex) == -2 && (yCur - yNex) == 1) || ((xCur - xNex) == -2 && (yCur - yNex) == -1) || 
				((xCur - xNex) == -1 && (yCur - yNex) == -2) || ((xCur - xNex) == 1 && (yCur - yNex) == -2) || 
				((xCur - xNex) == 2 && (yCur - yNex) == -1) || ((xCur - xNex) == 2 && (yCur - yNex) == 1))
		{
			tmp = GameBoard[yCur][xCur];
			GameBoard[yNex][xNex] = tmp;
			GameBoard[yCur][xCur] = "  ";
			return true;	
		}
		else {return false;}
	}
	////////////////// end if item is a Knight /////////////////////////////
	//********************************************************** //
	
	////////////////// begin if item is The King /////////////////////
	public boolean ifKing(int xCur, int yCur, int xNex, int yNex)
	{
		String tmp;
		
		if (GameBoard[yCur][xCur].substring(1).equalsIgnoreCase(GameBoard[yNex][xNex].substring(1)))
		{
			System.out.println("Friendly Fight Is Not Allowed");
			return false;
		}
		
		if (yCur == yNex && xCur < xNex && (xNex - xCur) == 1) // movint to the right //
		{
			tmp = GameBoard[yCur][xCur];
			GameBoard[yNex][xNex] = tmp;
			GameBoard[yCur][xCur] = "  ";
			return true;
		}
		
		else if (yCur == yNex && xCur > xNex && (xNex - xCur) == -1) // moving to the left //
		{
			tmp = GameBoard[yCur][xCur];
			GameBoard[yNex][xNex] = tmp;
			GameBoard[yCur][xCur] = "  ";
			return true;
		}
		else if (xCur == xNex && (yCur - yNex) == 1) // moving upward //
		{
			tmp = GameBoard[yCur][xCur];
			GameBoard[yNex][xNex] = tmp;
			GameBoard[yCur][xCur] = "  ";
			return true;
		}
		else if (xCur == xNex && (yCur - yNex) == -1) // moving downward //
		{
			tmp = GameBoard[yCur][xCur];
			GameBoard[yNex][xNex] = tmp;
			GameBoard[yCur][xCur] = "  ";
			return true;
		}
		else if ((xCur - xNex) == -1 && (yCur - yNex) == 1) // moving north east //
		{
			tmp = GameBoard[yCur][xCur];
			GameBoard[yNex][xNex] = tmp;
			GameBoard[yCur][xCur] = "  ";
			return true;
		}
		else if ((xCur - xNex) == 1 && (yCur - yNex) == 1) // moving north west //
		{
			tmp = GameBoard[yCur][xCur];
			GameBoard[yNex][xNex] = tmp;
			GameBoard[yCur][xCur] = "  ";
			return true;
		}
		else if ((xCur - xNex) == -1 && (yCur - yNex) == -1) // moving south east //
		{
			tmp = GameBoard[yCur][xCur];
			GameBoard[yNex][xNex] = tmp;
			GameBoard[yCur][xCur] = "  ";
			return true;
		}
		else if ((xCur - xNex) == 1 && (yCur - yNex) == -1) // moving south west //
		{
			tmp = GameBoard[yCur][xCur];
			GameBoard[yNex][xNex] = tmp;
			GameBoard[yCur][xCur] = "  ";
			return true;
		}
		
		return false;
	}
	/////////////////////// end if item is The King ////////////////////////
	//********************************************************** //
	
	///////////////////// begin if item is Queen //////////////
	public boolean ifQueen(int xCur, int yCur, int xNex, int yNex)
	{
		String tmp;
		
		if (GameBoard[yCur][xCur].substring(1).equalsIgnoreCase(GameBoard[yNex][xNex].substring(1)))
		{
			System.out.println("Friendly Fight Is Not Allowed");
			return false;
		}
		
		if (xCur == xNex && yCur != yNex) // moving vertically begin //
		{
				if (yCur > yNex) // moving vertically upward //
				{
					for (int i=yNex+1; i<yCur; i++)
					{
						if (!GameBoard[i][xCur].equalsIgnoreCase("  "))
						{
							return false;
						}
					}
					tmp = GameBoard[yCur][xCur];
					GameBoard[yNex][xNex] = tmp;
					GameBoard[yCur][xCur] = "  ";
					return true;
				}
				else if (yCur < yNex) // moving vertically downward //
				{
					for (int i=yCur+1; i<yNex; i++)
					{
						if (!GameBoard[i][xCur].equalsIgnoreCase("  "))
						{
							return false;
						}
					}
					tmp = GameBoard[yCur][xCur];
					GameBoard[yNex][xNex] = tmp;
					GameBoard[yCur][xCur] = "  ";
					return true;
				}
		} // moving vertically end //
		
		else if (yCur == yNex && xCur != xNex) // moving horizontally begin //
		{
				if (xCur < xNex) // moving horizontally right //
				{
					for (int i=xCur+1; i<xNex; i++)
					{
						if (!GameBoard[yCur][i].equalsIgnoreCase("  "))
						{
							return false;
						}
					}
					tmp = GameBoard[yCur][xCur];
					GameBoard[yNex][xNex] = tmp;
					GameBoard[yCur][xCur] = "  ";
					return true;
				}
				else if (xCur > xNex) // moving horizontally left //
				{
					for (int i=xNex+1; i<xCur; i++)
					{
						if (!GameBoard[yCur][i].equalsIgnoreCase("  "))
						{
							return false;
						}
					}
					tmp = GameBoard[yCur][xCur];
					GameBoard[yNex][xNex] = tmp;
					GameBoard[yCur][xCur] = "  ";
					return true;
				}
		} // moving horizontally end //
		
		////////////////// begin queen move as bishop ////////////////////////////////////
		else
		{
			if (xCur > xNex && yCur > yNex && (xCur - xNex) == (yCur - yNex)) // moving to the north west // 
			{
				int count=1;
				for (int i=yNex+1; i<yCur; i++) // check only the middle //
				{
					if (!GameBoard[yNex+count][xNex+count].equalsIgnoreCase("  "))
					{
						return false;
					}
					count++;
				}
				tmp = GameBoard[yCur][xCur];
				GameBoard[yNex][xNex] = tmp;
				GameBoard[yCur][xCur] = "  ";
				return true;
			}// end moving north west //
		
			else if (((xCur < xNex) && (yCur < yNex)) && (xCur - xNex) == (yCur - yNex)) // moving to the south east // 
			{
				int count=1;
				for (int i=yCur+1; i<yNex; i++) // check only the middle //
				{
					if (!GameBoard[i][xCur+count].equalsIgnoreCase("  "))
					{
						return false;
					}	
					count++;
				}
				tmp = GameBoard[yCur][xCur];
				GameBoard[yNex][xNex] = tmp;
				GameBoard[yCur][xCur] = "  ";
				return true;
			}// end moving north west //
		
			else if (((xCur < xNex) && (yCur > yNex)) && (xCur - xNex) == (yNex - yCur)) // moving to the north east // 
			{
				int count=1;
				for (int i=yNex+1; i<yCur; i++) // check only the middle //
				{
					if (!GameBoard[i][xNex-count].equalsIgnoreCase("  "))
					{
						return false;
					}
					count++;
				}
				tmp = GameBoard[yCur][xCur];
				GameBoard[yNex][xNex] = tmp;
				GameBoard[yCur][xCur] = "  ";
				return true;
			}	// 	end moving north west //
		
			else if (((xCur > xNex) && (yCur < yNex)) && (xCur - xNex) == (yNex - yCur)) // moving to the south west // 
			{
				int count=1;
				for (int i=yCur+1; i<yNex; i++) // check only the middle //
				{
					if (!GameBoard[i][xCur-count].equalsIgnoreCase("  "))
					{
						return false;
					}
					count++;
				}
				tmp = GameBoard[yCur][xCur];
				GameBoard[yNex][xNex] = tmp;
				GameBoard[yCur][xCur] = "  ";
				return true;
			}	// end moving north west //
		}
			return false;
	}
	/////////////// end if item is Queen ////////////////////////
	//********************************************************** //
	
	///////////////////// begin move /////////////////////////////////
	public boolean move(String type, String pos)
	{
		boolean validMove = false;
		
		int xNex=0, yNex=0;
		int xCur=0,yCur=0;
		
		xCur = (type.charAt(0) - 48) - 1;
		yCur = (type.charAt(1) - 48) - 1;
		
		xNex = (pos.charAt(0) - 48) - 1;
		yNex = (pos.charAt(1) - 48) - 1;
		
		type = GameBoard[yCur][xCur];
		
		if (GameBoard[yNex][xNex].equalsIgnoreCase("K1") || GameBoard[yNex][xNex].equalsIgnoreCase("K2"))
		{
			checkForMatt = true; // check if King is matt;
		}
		if (currentPlayer.equalsIgnoreCase("1"))
		{
			if (GameBoard[yCur][xCur].substring(1).equalsIgnoreCase("2"))
			{
				System.out.println("This Item Is Not Belongs To You");
				return false;
			}
		}
		if (currentPlayer.equalsIgnoreCase("2"))
		{
			if (GameBoard[yCur][xCur].substring(1).equalsIgnoreCase("1"))
			{
				System.out.println("This Item Is Not Belongs To You");
				return false;
			}
		}
		
		if (type.equalsIgnoreCase("P1") || type.equalsIgnoreCase("P2")) // if item is a pawn // 
		{
			validMove = ifPawn(xCur, yCur, xNex, yNex);
			if (validMove == true)
			{
				return true;
			}
			else {return false;}
		}

		else if (type.equalsIgnoreCase("R1") || type.equalsIgnoreCase("R2")) // if item is a Rook //
		{
			validMove = ifRook(xCur, yCur, xNex, yNex);
			if (validMove == true)
			{
				return true;
			}
			else {return false;}
		}
		
		else if (type.equalsIgnoreCase("B1") || type.equalsIgnoreCase("B2")) // if item is a Bishop //
		{
			validMove = ifBishop(xCur, yCur, xNex, yNex);
			if (validMove == true)
			{
				return true;
			}
			else {return false;}
		}
		
		else if (type.equalsIgnoreCase("H1") || type.equalsIgnoreCase("H2")) // if item is a Knight //
		{
			validMove = ifKnight(xCur, yCur, xNex, yNex);
			if (validMove == true)
			{
				return true;
			}
			else {return false;}
		}
		
		else if(type.equalsIgnoreCase("Q1") || type.equalsIgnoreCase("Q2")) // if item is Queen //
		{
			validMove = ifQueen(xCur, yCur, xNex, yNex);
			if (validMove == true)
			{
				return true;
			}
			else {return false;}
		}
		
		else if (type.equalsIgnoreCase("K1") || type.equalsIgnoreCase("K2")) // if item is King //
		{
			validMove = ifKing(xCur, yCur, xNex, yNex);
			if (validMove == true)
			{
				return true;
			}
			else {return false;}
		}
		
		return false;
	}
	
	public static void main(String args[])
	{
		Chess ches = new Chess();
		ches.initializeBoard();
		ches.printBoard();

		System.out.println();
		boolean winner = false, checkForValidPos;
		
		// Begin The Game //
		
		
		int play1=0, play2=0, whoStart=0;
		String player, player1=null, player2=null;
		int PlayOrExit=0, gamePlayed=0, noWinner=0;
		Scanner scnr = new Scanner(System.in);
		String type, newCordinate;
		
		System.out.println("Welcome To The Smart Chess");	

			System.out.println("Enter Player 1 Name");
			player1 = scnr.nextLine();
			System.out.println("Enter Player 2 Name");
			player2 = scnr.nextLine();
				
			while (PlayOrExit != 2)
			{
				ches.printBoard();
					System.out.println("Who Want To Start First. 1- "+player1 +"(1) , 2- " +player2 + "(2)");
	
					whoStart = scnr.nextInt();

						if (whoStart == 1)
						{
							player = player1;
						}
						else
						{
							player = player2;
						}
		
					while (ches.checkForMatt != true)
					{
							if (player.equalsIgnoreCase(player1))
							{
								System.out.println(player + " - Enter The Cordinates of The Item" +
															" You Want To Move (X/Y)");
								type = scnr.next();
								System.out.println(player + " - Enter The New Position Cordinates (X/Y)");
								newCordinate = scnr.next();
								
									ches.currentPlayer = "1";
									checkForValidPos = ches.move(type, newCordinate);
									
									if (checkForValidPos == true)
									{
										player = player2;
										winner = ches.checkWinner();
									}
									else
									{
										System.out.println("Invalid Move");
									}
							}
							
							else if (player.equalsIgnoreCase(player2))
							{	
								System.out.println(player + " - Enter The Cordinates of The Item" +
															" You Want To Move (X/Y)");
								type = scnr.next();
								System.out.println(player + " - Enter The New Position Cordinates (X/Y)");
								newCordinate = scnr.next();
								ches.currentPlayer = "2";
								checkForValidPos = ches.move(type, newCordinate);
								
								
								if (checkForValidPos == true)
								{
									player = player1;
									winner = ches.checkWinner();
								}
								else
								{
									System.out.println("Invalid Move");
								}
							
							}
							ches.printBoard();
					}
			
					// Winner Decision //

					if (player.equalsIgnoreCase(player2))
					{
							System.out.println(player1 + " Has Won");
							gamePlayed++;
							play1++;
					}
					else if (player.equalsIgnoreCase(player1))
					{
							System.out.println(player2 + " Has Won");
							gamePlayed++;
							play2++;
					}
		
					System.out.println("To Play Again Enter 1, To Exit Enter 2");
					PlayOrExit = scnr.nextInt();
					if (PlayOrExit == 2)
					{	
						System.out.println("Game Records :");
						System.out.println("-------------------------------");
						System.out.println("Game Played : " + gamePlayed + " Times");
						System.out.println(player1 + " Has Won " + play1 + " Times");
						System.out.println(player2 + " Has Won " + play2 + " Times");
						System.out.println("-------------------------------");
						System.out.println("Written By Ahmad Jawed ZAFAR, Bye Bye");
						System.exit(0);
					}
					else
					{
						System.console();
						ches.initializeBoard();
						noWinner=0;
						winner = false;
					}
			}
	}

}