// constructor public ChessBoard() { battleChessMain = null; bitBoard = new ChessBitBoard(); bitBoardVirtual = new ChessBitBoard(); }
public int Score(Move move, ChessBitBoard board, Team team) { if (_score == -1) { _score = Evaluate(move, board, team); } return(_score); }
public static ChessMove ToChessMove(this Move move, ChessBitBoard board, Team team) { var enemyTeam = team == Team.White ? Team.Black : Team.White; var flag = GetMoveFlag(board, move, enemyTeam); var srcy = 7 - move.srce.Y; var desty = 7 - move.dest.Y; return(new ChessMove(new ChessLocation(move.srce.X, srcy), new ChessLocation(move.dest.X, desty), flag)); }
public bool ValidateMove(ChessBitBoard bitBoard, ChessMove moveToCheck, ChessColor colorOfPlayerMoving) { // When playing against an AI opponent, the framework will only call this method // if the AI didn't declare a stalemate or go over its time. This means we're // guaranteed to have a move and only need to check for check and stalemate. // We'll still check for stalemate in case it's a human player though. if (moveToCheck.Flag == ChessFlag.Stalemate) { var allWhiteMoves = new Queue <Move>(); var allBlackMoves = new Queue <Move>(); bitBoard.getAllValidMoves(Team.White, allWhiteMoves); bitBoard.getAllValidMoves(Team.Black, allBlackMoves); return(allWhiteMoves.Count == 0 && allBlackMoves.Count == 0); } // convert from the frameworks coordinates to cartesian var srcy = 7 - moveToCheck.From.Y; var desty = 7 - moveToCheck.To.Y; var team = colorOfPlayerMoving == ChessColor.White ? Team.White : Team.Black; var enemyTeam = team == Team.White ? Team.Black : Team.White; var actualTeam = bitBoard.getPieceTeam(moveToCheck.From.X, srcy); if (team != actualTeam) { return(false); } if (!bitBoard.validateMove(moveToCheck.From.X, srcy, moveToCheck.To.X, desty)) { return(false); } bitBoard.move(moveToCheck.From.X, srcy, moveToCheck.To.X, desty); if (bitBoard.lastMove().causesCheck) { var allEnemyMoves = new Queue <Move>(); bitBoard.getAllValidMoves(enemyTeam, allEnemyMoves); if (allEnemyMoves.Count == 0) { return(moveToCheck.Flag == ChessFlag.Checkmate); } else { return(moveToCheck.Flag == ChessFlag.Check); } } return(moveToCheck.Flag == ChessFlag.NoFlag); }
public Move getNextMove(ChessBitBoard board, Team team) { var chessMove = ai.GetNextMove(board.ToChessBoard(), team.ToChessColor()); var srcy = 7 - chessMove.From.Y; var desty = 7 - chessMove.To.Y; board.move(chessMove.From.X, srcy, chessMove.To.X, desty); var move = board.lastMove(); board.rollBackMove(); return(move); }
public bool IsStalemate(ChessBitBoard bitBoard, Queue <Move> allMyMoves, Team enemyTeam) { var allEnemyMoves = new Queue <Move>(); if (allMyMoves.Count == 0) { bitBoard.getAllValidMoves(enemyTeam, allEnemyMoves); if (allEnemyMoves.Count == 0) { return(true); } } return(false); }
public ChessFlag GetMoveFlag(ChessBitBoard bitBoard, Move move, Team enemyTeam) { var flag = ChessFlag.NoFlag; var allEnemyMoves = new Queue <Move>(); if (move.causesCheck) { bitBoard.move(move.srce.X, move.srce.Y, move.dest.X, move.dest.Y); bitBoard.getAllValidMoves(enemyTeam, allEnemyMoves); if (allEnemyMoves.Count == 0) { flag = ChessFlag.Checkmate; } else { flag = ChessFlag.Check; } } return(flag); }
public void CopyFrom( ChessBitBoard bitBoard ) { for( int i=0; i<NumPieceBB; ++i ) { pieceBB[i] = bitBoard.pieceBB[i]; } emptyBB = bitBoard.emptyBB; occupiedBB = bitBoard.occupiedBB; currCastlingState = bitBoard.currCastlingState; currEnPassantTrgSq = bitBoard.currEnPassantTrgSq; }
public bool isValidMove(ChessBitBoard board, Move move, Team team) { return(ai.IsValidMove(board.ToChessBoard(), move.ToChessMove(board, team), team.ToChessColor())); }
public static ChessBoard ToChessBoard(this ChessBitBoard bitBoard) { var chessBoard = new ChessBoard(); for (int x = 0; x < 8; ++x) { for (int y = 0; y < 8; ++y) { var pieceTeam = bitBoard.getPieceTeam(x, y); var pieceType = bitBoard.getPieceType(x, y); var y2 = 7 - y; if (pieceTeam == Team.Black) { switch (pieceType) { case Piece.Bishop: chessBoard[x, y2] = ChessPiece.BlackBishop; break; case Piece.King: chessBoard[x, y2] = ChessPiece.BlackKing; break; case Piece.Knight: chessBoard[x, y2] = ChessPiece.BlackKnight; break; case Piece.Pawn: chessBoard[x, y2] = ChessPiece.BlackPawn; break; case Piece.Queen: chessBoard[x, y2] = ChessPiece.BlackQueen; break; case Piece.Rook: chessBoard[x, y2] = ChessPiece.BlackRook; break; default: chessBoard[x, y2] = ChessPiece.Empty; break; } } else { switch (pieceType) { case Piece.Bishop: chessBoard[x, y2] = ChessPiece.WhiteBishop; break; case Piece.King: chessBoard[x, y2] = ChessPiece.WhiteKing; break; case Piece.Knight: chessBoard[x, y2] = ChessPiece.WhiteKnight; break; case Piece.Pawn: chessBoard[x, y2] = ChessPiece.WhitePawn; break; case Piece.Queen: chessBoard[x, y2] = ChessPiece.WhiteQueen; break; case Piece.Rook: chessBoard[x, y2] = ChessPiece.WhiteRook; break; default: chessBoard[x, y2] = ChessPiece.Empty; break; } } } } return(chessBoard); }