void DisplayChessboard(ChessPiece[,] chessboard) { string[] colLetters = { " ", "A ", "B ", "C ", "D ", "E ", "F ", "G ", "H " }; for (int row = 0; row < chessboard.GetLength(0) + 1; row++) { for (int col = 0; col < chessboard.GetLength(1) + 1; col++) { if (row == 0) { Console.Write("{0} ", colLetters[col]); continue; } else if (col == 0) { Console.Write("{0} ", row); continue; } if ((row + col) % 2 == 0) { Console.BackgroundColor = ConsoleColor.DarkYellow; } else { Console.BackgroundColor = ConsoleColor.Gray; } DisplayChessPiece(chessboard[row - 1, col - 1]); Console.ResetColor(); } Console.WriteLine(); } }
private void LoadPieceCache() { lock (pieceCacheLocked) { whitePieceCache = new List <ChessPiece>(); blackPieceCache = new List <ChessPiece>(); for (int x = 0; x < pieces.GetLength(0); x++) { for (int y = 0; y < pieces.GetLength(1); y++) { var pieceAt = pieces[x, y]; if (pieceAt == null) { continue; } if (pieceAt.Color == PieceColor.White) { whitePieceCache.Add(pieceAt); } else { blackPieceCache.Add(pieceAt); } } } cacheSet = true; } }
public static Player[,] MapToEngineBoard(ChessPiece[,] source, Player blackPlayer) { var b = new Player[source.GetLength(0), source.GetLength(1)]; for (int i = 0; i < b.GetLength(0); i++) { for (int j = 0; j < b.GetLength(1); j++) { ref var d = ref b[i, j]; switch (source[i, j]) { case ChessPiece.Empty: d = Player.Empty; break; case ChessPiece.Black: d = blackPlayer; break; case ChessPiece.White: d = blackPlayer.OppositePlayer(); break; } } }
void DisplayChessBoard(ChessPiece[,] chessboard) { Console.WriteLine(" A B C D E F G H"); for (int r = 0; r < chessboard.GetLength(1); r++) { Console.Write($"{r+1} "); for (int k = 0; k < chessboard.GetLength(1); k++) { if ((r + k) % 2 == 0) { Console.BackgroundColor = ConsoleColor.DarkYellow; } else { Console.BackgroundColor = ConsoleColor.Gray; } DisplayChessPiece(chessboard[r, k]); if (k + 1 == chessboard.GetLength(1)) { k = 0; Console.WriteLine(); break; } } Console.ResetColor(); } }
void PutChessPieces(ChessPiece[,] chessboard) { ChessPieceType[] order = { ChessPieceType.Rook, ChessPieceType.Knight, ChessPieceType.Bishop, ChessPieceType.King, ChessPieceType.Queen, ChessPieceType.Bishop, ChessPieceType.Knight, ChessPieceType.Rook }; for (int row = 0; row < chessboard.GetLength(0); row++) { for (int col = 0; col < chessboard.GetLength(1); col++) { // Set type if (row == 1 || row == 6) { chessboard[row, col] = new ChessPiece(); chessboard[row, col].type = ChessPieceType.Pawn; } else if (row == 0 || row == 7) { chessboard[row, col] = new ChessPiece(); chessboard[row, col].type = order[col]; } // Set color if (row == 0 || row == 1) { chessboard[row, col].color = ChessPieceColor.White; } else if (row == 6 || row == 7) { chessboard[row, col].color = ChessPieceColor.Black; } } } }
void DisplayChessboard(ChessPiece[,] chessboard) { Console.Write(" A B C D E F G H"); Console.WriteLine(); int count = 0; for (int i = 0; i < chessboard.GetLength(0); i++) { for (int j = 0; j < chessboard.GetLength(1); j++) { if (j == 0) { count++; Console.Write("{0} ", count); } if ((i + j) % 2 == 0) { Console.BackgroundColor = ConsoleColor.DarkYellow; } else { Console.BackgroundColor = ConsoleColor.Gray; } DisplayChessPiece(chessboard[i, j]); Console.ResetColor(); } Console.WriteLine(); } }
void PutChessPieces(ChessPiece[,] chessboard) { ChessPieceType[] order = { ChessPieceType.Rook, ChessPieceType.Knight, ChessPieceType.Bishop, ChessPieceType.King, ChessPieceType.Queen, ChessPieceType.Bishop, ChessPieceType.Knight, ChessPieceType.Rook }; for (int i = 0; i < chessboard.GetLength(0); i++) { for (int j = 0; j < chessboard.GetLength(1); j++) { if (i == 1 || i == 6) { chessboard[i, j] = new ChessPiece(); chessboard[i, j].Type = ChessPieceType.Pawn; } else if (i == 0 || i == 7) { chessboard[i, j] = new ChessPiece(); chessboard[i, j].Type = order[j]; } if (i == 0 || i == 1) { chessboard[i, j].Color = ChessPieceColor.White; } else if (i == 6 || i == 7) { chessboard[i, j].Color = ChessPieceColor.Black; } } } }
public static void PrintBoard(ChessPiece[,] pieces, bool[,] possibleMoves) { ConsoleColor originalBackground = Console.BackgroundColor; ConsoleColor greyBackground = ConsoleColor.DarkGray; for (int i = 0; i < pieces.GetLength(0); i++) { Console.Write(8 - i + " "); for (int j = 0; j < pieces.GetLength(1); j++) { if (possibleMoves[i, j]) { Console.BackgroundColor = greyBackground; PrintPiece(pieces[i, j]); Console.BackgroundColor = originalBackground; } else { PrintPiece(pieces[i, j]); } } Console.WriteLine(); } Console.WriteLine(" a b c d e f g h"); Console.BackgroundColor = originalBackground; }
void PutChessPieces(ChessPiece[,] chessboard) { ChessPieceType[] order = { ChessPieceType.Rook, ChessPieceType.Knight, ChessPieceType.Bishop, ChessPieceType.King, ChessPieceType.Queen, ChessPieceType.Bishop, ChessPieceType.Knight, ChessPieceType.Rook }; for (int c = 0; c < chessboard.GetLength(1); c++) { chessboard[1, c] = new ChessPiece { colour = ChessPieceColour.White, type = ChessPieceType.Pawn }; chessboard[6, c] = new ChessPiece { colour = ChessPieceColour.Black, type = ChessPieceType.Pawn }; } for (int c = 0; c < chessboard.GetLength(1); c++) { chessboard[0, c] = new ChessPiece { colour = ChessPieceColour.White, type = order[c] }; chessboard[7, c] = new ChessPiece { colour = ChessPieceColour.Black, type = order[c] }; } }
public void CheckMove(ChessPiece[,] chessboard, Position from, Position to, Turn turn) { if (chessboard[from.row, from.col] == null) { throw new Exception("No chesspiece at current 'from' coordinates"); } else if (!(chessboard[to.row, to.col] == null)) { if (chessboard[from.row, from.col].colour == chessboard[to.row, to.col].colour) { throw new Exception("A chesspiece is already at the currently chosen 'to' coordinates"); } else { Console.ForegroundColor = ConsoleColor.Red; Console.WriteLine($"{chessboard[to.row, to.col].colour} {chessboard[to.row, to.col].type} has been eliminated!"); Console.ResetColor(); DeadPieces(chessboard[to.row, to.col]); } } else if (!ValidMove(chessboard, chessboard[from.row, from.col], from, to)) { throw new Exception("Move is invalid for this chesspiece"); } else if (from.col >= chessboard.GetLength(1) || from.row >= chessboard.GetLength(0) || to.col >= chessboard.GetLength(1) || to.row >= chessboard.GetLength(0)) { throw new Exception("Coordinates out of bounds"); } else if ((turn == Turn.Black && chessboard[from.row, from.col].colour == ChessPieceColour.White) || (turn == Turn.White && chessboard[from.row, from.col].colour == ChessPieceColour.Black)) { throw new Exception($"The {turn} player can only move pieces of colour {turn}"); } }
void PutChessPieces(ref ChessPiece[,] chessboard) { ChessPieceType[] order = { ChessPieceType.Rook, ChessPieceType.Knight, ChessPieceType.Bishop, ChessPieceType.King, ChessPieceType.Queen, ChessPieceType.Bishop, ChessPieceType.Knight, ChessPieceType.Rook }; for (int r = 0; r < chessboard.GetLength(0); r++) { for (int c = 0; c < chessboard.GetLength(1); c++) { if (r == 0) { chessboard[r, c] = new ChessPiece(ChessPieceColor.White, order[c]); } else if (r == 1) { chessboard[r, c] = new ChessPiece(ChessPieceColor.White, ChessPieceType.Pawn); } else if (r == 6) { chessboard[r, c] = new ChessPiece(ChessPieceColor.Black, ChessPieceType.Pawn); } else if (r == 7) { chessboard[r, c] = new ChessPiece(ChessPieceColor.Black, order[c]); } } } }
public bool GameCheck(ChessPiece[,] chessboard, int move) { int kings = 0; for (int r = 0; r < chessboard.GetLength(0); r++) { for (int c = 0; c < chessboard.GetLength(1); c++) { if (chessboard[r, c] != null && (chessboard[r, c].type == ChessPieceType.King)) { kings++; } } } if (kings == 2) { return(true); } else { Turn winner = DetermineTurn(move); if (winner == Turn.White) { Console.BackgroundColor = ConsoleColor.White; Console.ForegroundColor = ConsoleColor.Black; } else { Console.BackgroundColor = ConsoleColor.Gray; Console.ForegroundColor = ConsoleColor.White; } Console.WriteLine($"GAME OVER - {winner} wins"); return(false); } }
public override List <Point> GetValidMoves() { ChessPiece[,] board = ChessBoard.GetBoard; List <Point> validMoves = new List <Point>(); for (int i = 0; i < board.GetLength(0); i++) { for (int j = 0; j < board.GetLength(1); j++) { if (!(j == Coordinates.Y && i == Coordinates.X) && (j == Coordinates.Y + 2 && i == Coordinates.X + 1 || j == Coordinates.Y + 2 && i == Coordinates.X - 1 || j == Coordinates.Y - 2 && i == Coordinates.X + 1 || j == Coordinates.Y - 2 && i == Coordinates.X - 1 || j == Coordinates.Y + 1 && i == Coordinates.X + 2 || j == Coordinates.Y + 1 && i == Coordinates.X - 2 || j == Coordinates.Y - 1 && i == Coordinates.X + 2 || j == Coordinates.Y - 1 && i == Coordinates.X - 2)) { validMoves.Add(new Point(i, j)); } } } validMoves = RemoveInvalidMoves(validMoves); return(validMoves); }
private bool IsCheckMate(Color color) { ChessPiece[,] board = GetBoard; King king = GetKing(color); for (int i = 0; i < board.GetLength(0); i++) { for (int j = 0; j < board.GetLength(1); j++) { ChessPiece chessPiece = board[i, j]; if (chessPiece != null) { if (chessPiece.GetColor == king.GetColor) { foreach (Point move in chessPiece.GetValidMoves()) { if (chessPiece.MoveResolvesCheck(color, move)) { return(false); } } } } } } return(true); }
void DisplayChessBoard(ChessPiece[,] chessboard) { Console.WriteLine(" A B C D E F G H "); for (int row = 0; row < chessboard.GetLength(0); row++) { Console.Write(row + 1 + " "); for (int col = 0; col < chessboard.GetLength(1); col++) { if ((row + col) % 2 == 0) { Console.BackgroundColor = ConsoleColor.DarkYellow; } else { Console.BackgroundColor = ConsoleColor.Gray; } DisplayChessPiece(chessboard[row, col]); Console.ResetColor(); } Console.WriteLine(); } Console.WriteLine(); }
void ClearPieces() { for (int x = 0; x < Pieces.GetLength(0); x++) { for (int y = 0; y < Pieces.GetLength(1); y++) { Pieces[x, y] = null; } } }
void InitChessboard(ChessPiece[,] chessboard) { for (int i = 0; i < chessboard.GetLength(0); i++) { for (int j = 0; j < chessboard.GetLength(1); j++) { chessboard[i, j] = null; } PutChessPieces(chessboard); } }
void InitChessboard(ChessPiece[,] chessboard) { for (int row = 0; row < chessboard.GetLength(0); row++) { for (int col = 0; col < chessboard.GetLength(1); col++) { chessboard[row, col] = null; } } PutChessPieces(chessboard); }
public void InitChessboard(ChessPiece[,] chessboard) { for (int r = 0; r < chessboard.GetLength(0); r++) { for (int c = 0; c < chessboard.GetLength(1); c++) { chessboard[r, c] = null; } } PutChessPieces(chessboard); }
/// <summary> /// 清空棋盘,重新开始 /// </summary> public void Clear() { for (int i = 0; i < chessboard.GetLength(0); i++) { for (int j = 0; j < chessboard.GetLength(1); j++) { chessboard[i, j] = ChessPiece.EMPTY; } } turn = ChessPiece.CROSS; }
void InitChessBoard(ChessPiece[,] chessboard) { for (int r = 0; r < chessboard.GetLength(0); r++) { for (int k = 0; k < chessboard.GetLength(1); k++) { chessboard[r, k] = null; } } PutChessPieces(chessboard); }
private void InitChessboard(ChessPiece[,] cb) { for (int r = 0; r < cb.GetLength(0); r++) { for (int c = 0; c < cb.GetLength(1); c++) { cb[r, c] = null; } } PutChessPieces(cb); }
private void DisplayChessboard(ChessPiece[,] cb) { Console.Write(" " + " A " + " B " + " C " + " D " + " E " + " F " + " G " + " H " + "\n"); for (int r = 0; r < chessboard.GetLength(0); r++) { Console.Write(r + 1 + " "); for (int c = 0; c < chessboard.GetLength(1); c++) { if ((r + c) % 2 == 0) { Console.BackgroundColor = ConsoleColor.DarkYellow; } else { Console.BackgroundColor = ConsoleColor.Gray; } ChessPiece cp = chessboard[r, c]; DisplayChessPiece(cp); Console.ResetColor(); } Console.WriteLine(); } /* for (int c = 0; c < cb.GetLength(0);c++) * { * for(int r = -1; r < cb.GetLength(1); r++) * { * if (r == -1) * { * Console.Write((c + 1) + " "); * } else * { * if ((r+c)%2==0) * { * Console.BackgroundColor = ConsoleColor.DarkYellow; * } * else * { * Console.BackgroundColor = ConsoleColor.Gray; * } * } * * * if(r >= 0) * { * DisplayChessPiece(cb[r, c]); * } * } * Console.WriteLine(); * Console.ResetColor(); * } */ }
public void InitChessboard() { for (int row = 0; row < chessboard.GetLength(0); row++) { for (int col = 0; col < chessboard.GetLength(1); col++) { chessboard[row, col] = null; } } PutChessPieces(); turn = ChessPieceColor.White; }
public static void PrintBoard(ChessPiece[,] chessPieces, bool[,] possibleMoves) { for (int i = 0; i < chessPieces.GetLength(0); i++) { Console.Write(8 - i + " "); for (int j = 0; j < chessPieces.GetLength(1); j++) { PrintPiece(chessPieces[i, j], possibleMoves[i, j]); } Console.WriteLine(); } Console.WriteLine(" a b c d e f g h"); }
private static ChessPiece[,] TurnBoard(ChessPiece[,] source) { var b = new ChessPiece[source.GetLength(0), source.GetLength(1)]; for (int i = 0; i < b.GetLength(0); i++) { for (int j = 0; j < b.GetLength(1); j++) { b[i, j] = source[b.GetUpperBound(0) - j, i]; } } return(b); }
public static void PrintBoard(ChessPiece[,] pieces) { for (int i = 0; i < pieces.GetLength(0); i++) { Console.Write(8 - i + " "); for (int j = 0; j < pieces.GetLength(1); j++) { PrintPiece(pieces[i, j]); } Console.WriteLine(); } Console.WriteLine(" a b c d e f g h"); }
private bool CheckMate() { var totalPossibleMoves = 0; for (var rowIndex = 0; rowIndex < _chessBoard.GetLength(0); rowIndex++) { for (var columnIndex = 0; columnIndex < _chessBoard.GetLength(1); columnIndex++) { var chessPiece = _chessBoard[rowIndex, columnIndex]; //Check for piece - is cell occupied? if (chessPiece.type == ChessPiece.PieceType.Empty) { break; } var position = new Vector2(columnIndex, rowIndex); //Get all legal moves for piece var legalMoves = GetLegalMoves(chessPiece, position); Debug.Log(chessPiece.color + " " + chessPiece.type + ": " + legalMoves.Count); totalPossibleMoves += legalMoves.Count; // foreach (var move in legalMoves) // { // //Make each move one by one // chessBoard[rowIndex, columnIndex] = new ChessPiece(ChessPiece.PieceType.Empty, ChessPiece.PieceColor.None, new Vector2(rowIndex, columnIndex)); // chessBoard[(int)move.x, (int)move.y] = chessPiece; // // //if the move does not result in the king being checked // if (!KingInCheck(chessPiece)) break; // // //Get all legal moves for the king under attack // var kingsMoves = GetLegalMoves(attackedPiece, attackedPiece.position); // // //if king cannot escape // if (!KingCanEscape(kingsMoves, chessPiece, position)) // { // //TODO: Check if other pieces can block the piece(s) that have King in check, break if true // // //If we haven't returned from any of the above checks on a given move, King must be in checkmate! // return true; // } // // //TODO: Undo last move, reset board to original state // } } } Debug.Log("Total possible legal moves: " + totalPossibleMoves); return(false); }
public void Init() { chessBoard = new ChessPiece[8, 8]; for (int x = 0; x < chessBoard.GetLength(0); x++) { for (int y = 0; y < chessBoard.GetLength(1); y++) { chessBoard[x, y] = null; } } ChessPieceHelper.InitChessPieces(ref chessBoard); whoIsActive = ChessPieceColor.White; winner = ChessPieceColor.None; }
private Board(List <Move> moveHistory, ChessPiece[,] pieces) { ChessPiece[,] piecesCopy = new ChessPiece[pieces.GetLength(0), pieces.GetLength(1)]; for (int x = 0; x < pieces.GetLength(0); x++) { for (int y = 0; y < pieces.GetLength(1); y++) { var pieceAtSpot = pieces[x, y]; if (pieceAtSpot != null) { piecesCopy[x, y] = pieceAtSpot.MoveTo(pieceAtSpot.Position); } } } this.pieces = piecesCopy; this.moveHistory = new List <Move>(moveHistory); }