/// <summary>
/// Applies friendly board to the bitboard and updates the visual board.
/// </summary>
/// <param name="friendlyBoard">The friendly board to apply.</param>
/// <param name="whiteMode">The white generator mode.</param>
/// <param name="blackMode">The black generator mode.</param>
/// <param name="quiescenceSearch">If true, only quiescence moves (mainly captures) will be generated.</param>
protected void CalculateBitboard(FriendlyBoard friendlyBoard, GeneratorMode whiteMode, GeneratorMode blackMode, bool quiescenceSearch)
{
Bitboard = new Bitboard(friendlyBoard);
Bitboard.Calculate(whiteMode, blackMode, quiescenceSearch);
VisualBoard.FriendlyBoard = new FriendlyBoard(Bitboard);
}
/// <summary>
/// Initializes a new instance of the <see cref="VisualBoard"/> class.
/// </summary>
/// <param name="piecesProvider">The pieces provider.</param>
public VisualBoard(PiecesProvider piecesProvider)
{
_piecesProvider = piecesProvider;
FriendlyBoard = new FriendlyBoard();
_selectionsManager = new SelectionsManager();
_axesManager = new AxesManager();
}
/// <summary>
/// Runs moves test with specific board and depth (0 = one level, 1 = two levels, ...).
/// If verifyIntegrity is false, then flag in returned MovesTestData object will be
/// always true.
/// </summary>
/// <param name="friendlyBoard">Initial board from which test will begin.</param>
/// <param name="depth">Number of in-depth nodes (where 0 means calculating moves only for initial board.</param>
/// <param name="calculateEndNodes">If true, every end node will calculate attacks and evaluation function.</param>
/// <param name="verifyIntegrity">If true, every board will be checked whether incremental-updating parameters are correctly calculated.</param>
/// <returns>Result of the test.</returns>
public MovesTestData Run(FriendlyBoard friendlyBoard, int depth, bool calculateEndNodes, bool verifyIntegrity)
{
var testData = new MovesTestData();
var stopwatch = new Stopwatch();
stopwatch.Start();
CalculateBitboard(_initialColor, new Bitboard(friendlyBoard), depth, calculateEndNodes, verifyIntegrity, testData);
testData.Ticks = stopwatch.Elapsed.Ticks;
return(testData);
}
/// <summary>
/// Writes <see cref="FriendlyBoard"/> object to the specified file.
/// </summary>
/// <param name="path">The path to file.</param>
/// <param name="friendlyBoard">The board to save.</param>
public void Write(string path, FriendlyBoard friendlyBoard)
{
using (var writer = new StreamWriter(path))
{
WriteBoard(writer, friendlyBoard.Pieces);
writer.WriteLine();
WriteCastling(writer, friendlyBoard.Castling);
writer.WriteLine();
WriteEnPassant(writer, friendlyBoard.EnPassant);
}
}
private Stream GetBoardImage()
{
var board = new Image <Rgba32>(527, 535);
var odd = false;
for (var x = 0; x < 8; x++)
{
for (var y = 0; y < 8; y++)
{
var field = odd ? _images["Field1"] : _images["Field2"];
board.Mutate(p => p.DrawImage(field, PixelBlenderMode.Overlay, 1, new SixLabors.Primitives.Point(15 + x * 64, y * 64)));
odd = !odd;
}
odd = !odd;
}
for (var x = 1; x <= 8; x++)
{
board.Mutate(p => p.DrawText(((char)(x + 'a' - 1)).ToString(), SystemFonts.CreateFont("Liberation Mono", 20, FontStyle.Bold), new Rgba32(255, 255, 255), new SixLabors.Primitives.PointF(x * 64 - 25, 513)));
board.Mutate(p => p.DrawText((8 - x + 1).ToString(), SystemFonts.CreateFont("Liberation Mono", 20, FontStyle.Bold), new Rgba32(255, 255, 255), new SixLabors.Primitives.PointF(0, (x - 1) * 64 + 20)));
}
var friendlyBoard = new FriendlyBoard(_gameSession.Bitboard);
foreach (var piece in friendlyBoard.Pieces)
{
var image = _images[GetImageNameByPiece(piece.Type, piece.Color)];
board.Mutate(p => p.DrawImage(image, 1, new SixLabors.Primitives.Point(15 + (piece.Position.X - 1) * 64, (8 - piece.Position.Y) * 64)));
}
foreach (var selected in _selectedPositions)
{
board.Mutate(p => p.DrawImage(_images["InternalSelection"], 1, new SixLabors.Primitives.Point(15 + (selected.X - 1) * 64, (8 - selected.Y) * 64)));
}
var stream = new MemoryStream();
board.Save(stream, new PngEncoder());
stream.Position = 0;
return(stream);
}
/// <summary>
/// Initializes a new instance of the <see cref="Bitboard"/> class.
/// </summary>
/// <param name="friendlyBoard">The friendly board.</param>
public Bitboard(FriendlyBoard friendlyBoard) : this()
{
Pieces = friendlyBoard.GetPiecesArray();
CastlingPossibility = friendlyBoard.GetCastlingPossibilityArray();
CastlingDone = friendlyBoard.GetCastlingDoneArray();
EnPassant = friendlyBoard.GetEnPassantArray();
Occupancy = CalculateOccupancy();
Calculate(GeneratorMode.CalculateAttacks, false);
IncEvaluation = new IncrementalEvaluationData(GetDetailedEvaluation());
ClearCalculatedData();
Hash = GetNewHash();
CalculateGamePhase();
var random64 = new Random64();
for (var i = 0; i < History.Length; i++)
{
History[i] = random64.Next();
}
}
/// <summary>
/// Applies friendly board to the bitboard and updates the visual board (generator mode is set to CalculateAttacks for both colors).
/// </summary>
/// <param name="friendlyBoard">The friendly board to apply.</param>
/// <param name="quiescenceSearch">If true, only quiescence moves (mainly captures) will be generated.</param>
protected void CalculateBitboard(FriendlyBoard friendlyBoard, bool quiescenceSearch)
{
var mode = GeneratorMode.CalculateMoves | GeneratorMode.CalculateAttacks;
CalculateBitboard(friendlyBoard, mode, mode, quiescenceSearch);
}
