private static Bitmask64[] GenerateColumnBitmasks()
{
Bitmask64[] result = new Bitmask64[Board.ColumnCount];
for (int i = 0; i < result.Length; ++i)
{
result[i] = GenerateColumnBitmask(i);
}
return(result);
}
private static Bitmask64[] GenerateMoveBitmaskTable(Piece piece)
{
var result = new Bitmask64[Board.Board.SquareCount];
for (int i = 0; i < result.Length; ++i)
{
result[i] = GenerateMovesBitmask(piece, new BoardSquare(i));
}
return(result);
}
private static Bitmask64 GenerateColumnBitmask(int column)
{
var result = new Bitmask64();
for (int row = 0; row < Board.RowCount; ++row)
{
result.SetBit(new BoardSquare(row, column).IntValue);
}
return(result);
}
private static bool IsAllSquaresEmptyAlongHorizontalAttack(
Bitmask64 targetRookMovesBitmask,
int targetColumn,
int attackerColumn,
long freeSquares)
{
long rayAttack = targetRookMovesBitmask.Value &
GetBitmaskInBetweenColumns(targetColumn, attackerColumn).Value;
return(rayAttack == (rayAttack & freeSquares));
}
private static bool IsAllSquaresEmptyAlongVerticalAttack(
Bitmask64 targetRookMovesBitmask,
int targetRow,
int attackerRow,
long freeSquares)
{
long rayAttack = targetRookMovesBitmask.Value &
GetBitmaskInBetweenRows(targetRow, attackerRow).Value;
return(rayAttack == (rayAttack & freeSquares));
}
private static Bitmask64 RayBitmask(MoveDelta rayDelta, BoardSquare rayOrigin)
{
var result = new Bitmask64();
var currentSquare = rayOrigin;
while (rayDelta.IsCanApplyTo(currentSquare))
{
currentSquare = rayDelta.GetDestSquare(currentSquare);
result.SetBit(currentSquare.IntValue);
}
return(result);
}
private static bool IsAllSquaresEmptyAlongBishopAttack(
Bitmask64 targetBishopMovesBitmask,
BoardSquare targetSquare,
BoardSquare attackerSquare,
long freeSquares)
{
long rayAttack = targetBishopMovesBitmask.Value &
GetBitmaskInBetweenRows(targetSquare.Row, attackerSquare.Row).Value &
GetBitmaskInBetweenColumns(targetSquare.Column, attackerSquare.Column).Value;
return(rayAttack == (rayAttack & freeSquares));
}
private Bitmask64 CalculateOccupiedSquaresBitmask()
{
Bitmask64 occupiedSquares = new Bitmask64();
for (int squareIndex = 0; squareIndex < SquareCount; ++squareIndex)
{
if (!_pieceTable.IsEmpty(squareIndex))
{
occupiedSquares.SetBit(squareIndex);
}
}
return(occupiedSquares);
}
private static Bitmask64[] GenerateBimasksInBetweenIndices(Func <int, Bitmask64> bitmaskByIndexFunc)
{
var result = new Bitmask64[Board.SquareCount];
for (int index1 = 0; index1 < 8; ++index1)
{
for (int index2 = 0; index2 < 8; ++index2)
{
var index = index1 * Board.ColumnCount + index2;
result[index] = GenerateBimaskInBetweenIndices(index1, index2, bitmaskByIndexFunc);
}
}
return(result);
}
private static Bitmask64 GenerateBimaskInBetweenIndices(
int index1,
int index2,
Func <int, Bitmask64> bitmaskByIndexFunc)
{
var result = new Bitmask64();
int minIndex = Min(index1, index2);
int maxIndex = Max(index1, index2);
for (int index = minIndex + 1; index < maxIndex; ++index)
{
result = new Bitmask64(result.Value | bitmaskByIndexFunc(index).Value);
}
return(result);
}
private static Bitmask64 GenerateMovesBitmask(Piece piece, BoardSquare square)
{
var result = new Bitmask64();
if (piece == Piece.Bishop && square.IntValue == 16)
{
result = new Bitmask64();
}
var rayDeltas = piece == Piece.Bishop ? BishopRayDeltas : RookRayDeltas;
foreach (var rayDelta in rayDeltas)
{
result = new Bitmask64(result.Value | RayBitmask(rayDelta, square).Value);
}
return(result);
}
private static bool IsBishopAttack(
Bitmask64 targetBishopMovesBitmask,
BoardSquare targetSquare,
BoardSquare attackerSquare,
long freeSquares)
{
if (!IsBishopDelta(new MoveDelta(targetSquare, attackerSquare)))
{
return(false);
}
return(IsAllSquaresEmptyAlongBishopAttack(
targetBishopMovesBitmask,
targetSquare,
attackerSquare,
freeSquares));
}
private static bool IsRookAttack(
Bitmask64 targetRookMovesBitmask,
BoardSquare targetSquare,
BoardSquare attackerSquare,
long freeSquares)
{
if (targetSquare.Row == attackerSquare.Row)
{
return(IsAllSquaresEmptyAlongHorizontalAttack(
targetRookMovesBitmask,
targetSquare.Column,
attackerSquare.Column,
freeSquares));
}
else if (targetSquare.Column == attackerSquare.Column)
{
return(IsAllSquaresEmptyAlongVerticalAttack(
targetRookMovesBitmask,
targetSquare.Row,
attackerSquare.Row,
freeSquares));
}
return(false);
}
public Board(List <PieceOnBoard> pieces)
{
_pieceTable = new PieceTable(pieces);
_occupiedSquares = CalculateOccupiedSquaresBitmask();
}
