private ulong DiagonalAntidiagonalXray(ulong allPieces, ulong ownPieces, byte position) { var attacks = _slideMoveGenerator.DiagonalAntidiagonalSlide(allPieces, position); ownPieces &= attacks; var xrayAttacks = attacks ^ _slideMoveGenerator.DiagonalAntidiagonalSlide(allPieces ^ ownPieces, position); return(xrayAttacks); }
private void GetPotentialBishopMoves(Board board, Bitboard allowedFrom, Bitboard allowedTo, Move[] moves, ref int moveCount) { var piece = (Piece)(ChessPiece.Bishop | board.ColorToMove); var piecesBitmask = board.BitBoard[piece] & allowedFrom; var ownPieces = board.WhiteToMove ? board.WhitePieces : board.BlackPieces; while (piecesBitmask != 0) { var position = piecesBitmask.BitScanForward(); Bitboard slide = _slideMoveGenerator.DiagonalAntidiagonalSlide(board.AllPieces, position); slide &= ~ownPieces; slide &= allowedTo; BitmaskToMoves(board, slide, position, piece, moves, ref moveCount); piecesBitmask &= piecesBitmask - 1; } }
private MagicBitboardGenerationEntry InitEntry(Bitboard blockerMask, bool bishop, int pos) { var entry = new MagicBitboardGenerationEntry(); entry.Position = pos; entry.BlockerMask = blockerMask; entry.Bishop = bishop; var maskCopy = blockerMask; var bits = new List <int>(); while (maskCopy != 0) { var blockerPosition = maskCopy.BitScanForward(); bits.Add(blockerPosition); maskCopy &= maskCopy - 1; } var permutations = 1 << bits.Count; entry.BitCount = (byte)bits.Count; entry.Occupancies = new Bitboard[permutations]; entry.Moveboards = new Bitboard[permutations]; for (var i = 0; i < permutations; i++) { Bitboard occMask = 0; for (var j = 0; j < bits.Count; j++) { var shouldSet = (i & (1 << j)) > 0; if (shouldSet) { var bit = bits[j]; occMask |= 1UL << bit; } } entry.Occupancies[i] = occMask; var moveboard = bishop ? _otherSlideGenerator.DiagonalAntidiagonalSlide(occMask, pos) : _otherSlideGenerator.HorizontalVerticalSlide(occMask, pos); entry.Moveboards[i] = moveboard; } entry.MagicNumber = FindMagicNumber(entry); return(entry); }
void EvalBishop(Board b, EvaluationScores v, Position sq, Piece side, ulong[] pawnControl, ulong pinned) { int att = 0; int mob = 0; /************************************************************************** * Collect data about mobility and king attacks * **************************************************************************/ var slide = _slideGenerator.DiagonalAntidiagonalSlide(b.AllPieces, sq); var opponent = (side == ChessPiece.White ? b.BlackPieces : b.WhitePieces) & slide; var bitboard = 1UL << sq; if ((bitboard & pinned) == 0) { var emptyUncontrolled = b.EmptySquares & ~pawnControl[side ^ 1] & slide; mob += emptyUncontrolled.PopCount(); mob += opponent.PopCount(); } var emptyOrOpponentNearKing = (b.EmptySquares | opponent) & BitboardConstants.KingExtendedJumps[side ^ 1][b.KingPositions[side ^ 1]] & slide; att += emptyOrOpponentNearKing.PopCount(); v.mgMob[side] += 3 * (mob - 7); v.egMob[side] += 3 * (mob - 7); if (att > 0) { v.attCnt[side]++; v.attWeight[side] += 2 * att; } int tropism = getTropism(sq, b.KingPositions[side ^ 1]); v.mgTropism[side] += 2 * tropism; v.egTropism[side] += 1 * tropism; }
public bool IsKingSafeAfterMove(Board board, Move move) { var allPieces = board.AllPieces; var fromBitboard = 1UL << move.From; var toBitboard = 1UL << move.To; allPieces &= ~fromBitboard; allPieces |= toBitboard; var takesBitboard = toBitboard; if (move.EnPassant) { var enPassantedBitboard = board.WhiteToMove ? toBitboard >> 8 : toBitboard << 8; allPieces &= ~enPassantedBitboard; takesBitboard |= enPassantedBitboard; } var kingMove = move.Piece == ChessPiece.WhiteKing || move.Piece == ChessPiece.BlackKing; Byte myKingPos = kingMove ? move.To : board.KingPositions[board.ColorToMove]; //Position myKingPos = board.KingPositions[board.ColorToMove]; var invTakes = ~takesBitboard; UInt64 pawns; UInt64 knights; UInt64 bishops; UInt64 rooks; UInt64 queens; UInt64 kings; if (board.WhiteToMove) { pawns = board.BitBoard[ChessPiece.BlackPawn] & invTakes; knights = board.BitBoard[ChessPiece.BlackKnight] & invTakes; bishops = board.BitBoard[ChessPiece.BlackBishop] & invTakes; rooks = board.BitBoard[ChessPiece.BlackRook] & invTakes; queens = board.BitBoard[ChessPiece.BlackQueen] & invTakes; kings = board.BitBoard[ChessPiece.BlackKing] & invTakes; } else { pawns = board.BitBoard[ChessPiece.WhitePawn] & invTakes; knights = board.BitBoard[ChessPiece.WhiteKnight] & invTakes; bishops = board.BitBoard[ChessPiece.WhiteBishop] & invTakes; rooks = board.BitBoard[ChessPiece.WhiteRook] & invTakes; queens = board.BitBoard[ChessPiece.WhiteQueen] & invTakes; kings = board.BitBoard[ChessPiece.WhiteKing] & invTakes; } var knightAttack = BitboardConstants.KnightJumps[myKingPos]; if ((knightAttack & knights) != 0) { return(false); } var kingAttack = BitboardConstants.KingJumps[myKingPos]; if ((kingAttack & kings) != 0) { return(false); } var pawnAttack = BitboardConstants.PawnJumps[move.ColorToMove, myKingPos]; //AttacksService.GetAttackedByPawns(myKings, board.WhiteToMove); if ((pawnAttack & pawns) != 0) { return(false); } var diagonalAttack = _slideMoveGenerator.DiagonalAntidiagonalSlide(allPieces, myKingPos); if ((diagonalAttack & (bishops | queens)) != 0) { return(false); } var verticalAttack = _slideMoveGenerator.HorizontalVerticalSlide(allPieces, myKingPos); if ((verticalAttack & (rooks | queens)) != 0) { return(false); } return(true); }