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