// 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);
}
