public Move(GameEngine engine, Board board, Square fromSquare, Square toSquare, Piece pieceToTest) { _engine = engine; _board = board; FromSquare = fromSquare; ToSquare = toSquare; PieceMoved = pieceToTest; IsValidMove = TestMove(); }
public Move(GameEngine engine, Board board, Square fromSquare, Square toSquare, Piece pieceMoved, Piece pieceCaptured, bool isPacketMove, Piece.PieceType piecePromoted) { _engine = engine; _board = board; FromSquare = fromSquare; ToSquare = toSquare; PieceMoved = pieceMoved; PiecePromoted = piecePromoted; PieceCaptured = pieceCaptured; ProcessMove(isPacketMove); }
public static UInt64 GenerateBishopMoves(Square s, Piece.Colour c) { UInt64 validSquares; int sqIndex = BitboardHelper.GetIndexFromSquare(s); UInt64 bbBlockers = _board.AllPieces & BitboardHelper.OccupancyMaskBishop[sqIndex]; int databaseIndex = (int)((bbBlockers * BitboardHelper.MagicNumberBishop[sqIndex]) >> BitboardHelper.MagicNumberShiftsBishop[sqIndex]); if (c == Piece.Colour.White) validSquares = BitboardHelper.MagicMovesBishop[sqIndex][databaseIndex] & ~_board.WhitePieces; else if (c == Piece.Colour.Black) validSquares = BitboardHelper.MagicMovesBishop[sqIndex][databaseIndex] & ~_board.BlackPieces; else validSquares = BitboardHelper.MagicMovesBishop[sqIndex][databaseIndex]; return validSquares; }
private static string GetInitial(Piece.PieceType type) { switch (type) { case Piece.PieceType.Bishop: return "B"; case Piece.PieceType.Knight: return "N"; case Piece.PieceType.Queen: return "Q"; case Piece.PieceType.Rook: return "R"; case Piece.PieceType.King: return "K"; default: return "initial"; } }
private List<Square> GenerateMoves(Piece p, Square s) { //Call method based on Type of Piece passed in switch (p.Piece_Type) { case Piece.PieceType.King: return GetSquareListFromBB(MoveGen.GenerateKingMoves(s, p.ColorType)); case Piece.PieceType.Pawn: return GetSquareListFromBB(MoveGen.GeneratePawnMoves(s, p.ColorType)); case Piece.PieceType.Knight: return GetSquareListFromBB(MoveGen.GenerateKnightMoves(s, p.ColorType)); case Piece.PieceType.Bishop: return GetSquareListFromBB(MoveGen.GenerateBishopMoves(s, p.ColorType)); case Piece.PieceType.Rook: return GetSquareListFromBB(MoveGen.GenerateRookMoves(s, p.ColorType)); case Piece.PieceType.Queen: return GetSquareListFromBB(MoveGen.GenerateQueenMoves(s, p.ColorType)); default: return null; } }
public static UInt64 GenerateKingMoves(Square s, Piece.Colour c) { UInt64 myPieceBB = BitboardHelper.GetBitboardFromSquare(s); UInt64 myPieceBB_H_Clip = (myPieceBB & BitboardHelper.ClearFile[7]); UInt64 myPieceBB_A_Clip = (myPieceBB & BitboardHelper.ClearFile[0]); UInt64 validMovesBB = (myPieceBB_A_Clip << 7) | (myPieceBB << 8) | (myPieceBB_H_Clip << 9) | (myPieceBB_H_Clip << 1) | (myPieceBB_H_Clip >> 7) | (myPieceBB >> 8) | (myPieceBB_A_Clip >> 9) | (myPieceBB_A_Clip >> 1); if (c == Piece.Colour.White) { //remove move options occupied by own side validMovesBB = validMovesBB ^ (validMovesBB & _board.WhitePieces); //Add Castling moves if available if (WhiteCanCastleShort && ((BitboardHelper.MaskWhiteCastleShort & _board.AllPieces) == 0)) validMovesBB |= myPieceBB << 2; if (WhiteCanCastleLong && ((BitboardHelper.MaskWhiteCastleLong & _board.AllPieces) == 0)) validMovesBB |= myPieceBB >> 2; } else { //remove move options occupied by own side validMovesBB = validMovesBB ^ (validMovesBB & _board.BlackPieces); //Add Castling moves if available if (BlackCanCastleShort && ((BitboardHelper.MaskBlackCastleShort & _board.AllPieces) == 0)) validMovesBB |= myPieceBB << 2; if (BlackCanCastleLong && ((BitboardHelper.MaskBlackCastleLong & _board.AllPieces) == 0)) validMovesBB |= myPieceBB >> 2; } return validMovesBB; }
public static UInt64 GenerateQueenMoves(Square s, Piece.Colour c) { //first calulate Rook movements for queen ulong validSquares = GenerateRookMoves(s, c); //then calculate Bishop moves for queen and OR with rook movements validSquares |= GenerateBishopMoves(s, c); return validSquares; }
public static List<Square> GenerateMoves(Piece pieceToMove, Square fromSq) { //Call method based on Type of Piece passed in List<Square> list = new List<Square>(); List<Square> result; switch (pieceToMove.Piece_Type) { case Piece.PieceType.King: result = new List<Square>(); list = _board.GetSquareListFromBB(GenerateKingMoves(fromSq, pieceToMove.ColorType)); if(list != null) { foreach (Square s in list) { var m = new Move(null, _board, fromSq, s, pieceToMove); if(m.IsValidMove) result.Add(m.ToSquare); } } return result; case Piece.PieceType.Pawn: result = new List<Square>(); list = _board.GetSquareListFromBB(GeneratePawnMoves(fromSq, pieceToMove.ColorType)); if(list != null) { foreach (Square s in list) { var m = new Move(null, _board, fromSq, s, pieceToMove); if(m.IsValidMove) result.Add(m.ToSquare); } } return result; case Piece.PieceType.Knight: result = new List<Square>(); list = _board.GetSquareListFromBB(GenerateKnightMoves(fromSq, pieceToMove.ColorType)); if(list != null) { foreach (Square s in list) { var m = new Move(null, _board, fromSq, s, pieceToMove); if(m.IsValidMove) result.Add(m.ToSquare); } } return result; case Piece.PieceType.Bishop: result = new List<Square>(); list = _board.GetSquareListFromBB(GenerateBishopMoves(fromSq, pieceToMove.ColorType)); if(list != null) { foreach (Square s in list) { var m = new Move(null, _board, fromSq, s, pieceToMove); if(m.IsValidMove) result.Add(m.ToSquare); } } return result; case Piece.PieceType.Rook: result = new List<Square>(); list = _board.GetSquareListFromBB(GenerateRookMoves(fromSq, pieceToMove.ColorType)); if(list != null) { foreach (Square s in list) { var m = new Move(null, _board, fromSq, s, pieceToMove); if(m.IsValidMove) result.Add(m.ToSquare); } } return result; case Piece.PieceType.Queen: result = new List<Square>(); list = _board.GetSquareListFromBB(GenerateQueenMoves(fromSq, pieceToMove.ColorType)); if(list != null) { foreach (Square s in list) { var m = new Move(null, _board, fromSq, s, pieceToMove); if(m.IsValidMove) result.Add(m.ToSquare); } } return result; default: return null; } }
public static UInt64 GeneratePawnMoves(Square s, Piece.Colour c) { UInt64 validMovesBB; UInt64 myPieceBB = BitboardHelper.GetBitboardFromSquare(s); //bitboard representation of the pawns position UInt64 myPieceBB_H_Clip = (myPieceBB & BitboardHelper.ClearFile[7]); UInt64 myPieceBB_A_Clip = (myPieceBB & BitboardHelper.ClearFile[0]); if (c == Piece.Colour.White) { validMovesBB = (myPieceBB_A_Clip << 7 | myPieceBB_H_Clip << 9) & _board.BlackPieces; if (((myPieceBB << 8) & _board.AllPieces) == 0) { validMovesBB = validMovesBB | (myPieceBB << 8); if (((myPieceBB & BitboardHelper.MaskRank[(int)Ranks.Two]) != 0) && ((myPieceBB << 16) & _board.AllPieces) == 0) validMovesBB = validMovesBB | (myPieceBB << 16); } #region enPassant? if (_board.AllMoves.Count != 0 && _board.AllMoves.Last().IsDoublePawnPush) //is lastmove was a double pawn push, need to check is en passant is possible { var lastPieceMovedBB = BitboardHelper.GetBitboardFromSquare(_board.AllMoves.Last().ToSquare); if ((myPieceBB >> 1) == lastPieceMovedBB) // if lastPieceMoved is one square to the left, add en passant capture to validMoves validMovesBB |= myPieceBB << 7; else if ((myPieceBB << 1) == lastPieceMovedBB)// if lastPieceMoved is one square to the right, add en passant capture to validMoves validMovesBB |= myPieceBB << 9; } #endregion } else { validMovesBB = (myPieceBB_H_Clip >> 7 | myPieceBB_A_Clip >> 9) & _board.WhitePieces; if (((myPieceBB >> 8) & _board.AllPieces) == 0) { validMovesBB = validMovesBB | (myPieceBB >> 8); if (((myPieceBB & BitboardHelper.MaskRank[(int)Ranks.Seven]) != 0) && ((myPieceBB >> 16) & _board.AllPieces) == 0) validMovesBB = validMovesBB | myPieceBB >> 16; } #region EnPassant? if (_board.AllMoves.Count > 0 & _board.AllMoves.Last().IsDoublePawnPush) //is lastmove was a double pawn push, need to check is en passant is possible { var lastPieceMovedBB = BitboardHelper.GetBitboardFromSquare(_board.AllMoves.Last().ToSquare); if ((myPieceBB >> 1) == lastPieceMovedBB) // if lastPieceMoved is one square to the left, add en passant capture to validMoves validMovesBB |= myPieceBB >> 9; else if ((myPieceBB << 1) == lastPieceMovedBB)// if lastPieceMoved is one square to the right, add en passant capture to validMoves validMovesBB |= myPieceBB >> 7; } #endregion } return validMovesBB; }
public void UpdateRelevantbb(Piece.PieceType type, Piece.Colour c, ulong bbFrom, ulong bbTo) { if (c == Piece.Colour.White) { switch (type) { case Piece.PieceType.Bishop: WhiteBishops ^= bbFrom; WhiteBishops ^= bbTo; break; case Piece.PieceType.King: WhiteKings ^= bbFrom; WhiteKings ^= bbTo; break; case Piece.PieceType.Knight: WhiteKnights ^= bbFrom; WhiteKnights ^= bbTo; break; case Piece.PieceType.Queen: WhiteQueens ^= bbFrom; WhiteQueens ^= bbTo; break; case Piece.PieceType.Rook: WhiteRooks ^= bbFrom; WhiteRooks ^= bbTo; break; case Piece.PieceType.Pawn: WhitePawns ^= bbFrom; WhitePawns ^= bbTo; break; } } else { switch (type) { case Piece.PieceType.Bishop: BlackBishops ^= bbFrom; BlackBishops ^= bbTo; break; case Piece.PieceType.King: BlackKings ^= bbFrom; BlackKings ^= bbTo; break; case Piece.PieceType.Knight: BlackKnights ^= bbFrom; BlackKnights ^= bbTo; break; case Piece.PieceType.Queen: BlackQueens ^= bbFrom; BlackQueens ^= bbTo; break; case Piece.PieceType.Rook: BlackRooks ^= bbFrom; BlackRooks ^= bbTo; break; case Piece.PieceType.Pawn: BlackPawns ^= bbFrom; BlackPawns ^= bbTo; break; } } }
public static UInt64 GenerateKnightMoves(Square s, Piece.Colour c) { UInt64 validMovesBB; int sqIndex = BitboardHelper.GetIndexFromSquare(s); if (c == Piece.Colour.White) validMovesBB = BitboardHelper.KnightAttacks[sqIndex] ^ (BitboardHelper.KnightAttacks[sqIndex]) & _board.WhitePieces; else if (c == Piece.Colour.Black) validMovesBB = BitboardHelper.KnightAttacks[sqIndex] ^ (BitboardHelper.KnightAttacks[sqIndex]) & _board.BlackPieces; else validMovesBB = BitboardHelper.KnightAttacks[sqIndex]; return validMovesBB; }
// Tests if king is in check after a piece is moved public bool TestMoveForCheck(Piece.Colour color) { switch (color) { case Piece.Colour.White: return TestForCheck(GetSquareFromBB(WhiteKings), true); case Piece.Colour.Black: return TestForCheck(GetSquareFromBB(BlackKings), false); } return false; }
public bool TestForPromotion(Piece.Colour c, Ranks rank) { switch (c) { case Piece.Colour.White: if (rank == Ranks.Eight) return true; break; case Piece.Colour.Black: if (rank == Ranks.One) return true; break; } return false; }
public bool TestForCheckmate(Piece.Colour c) { List<Square> list = new List<Square>(); switch (c) { case Piece.Colour.White: foreach (Piece p in White_Pieces) { list.AddRange(MoveGen.GenerateMoves(p, GetSquare(p))); } break; case Piece.Colour.Black: foreach (Piece p in Black_Pieces) { list.AddRange(MoveGen.GenerateMoves(p, GetSquare(p))); } break; } return list.Count == 0; }
public Square GetSquare(Piece p) { for (int i = 0; i < 8; i++) { for(int j = 0; j < 8; j++) { if (Squares[i, j].World.Translation == p.World.Translation - Adjust) return Squares[i, j]; } } return null; }
public void SetPromotion(Piece.PieceType promoteType) { PromoteTo = promoteType; SelectState = SelectionState.MoveSelected; }