// returns true if a piece to capture was detected
public static PieceMinified Check(PieceMinified piece, BoardMinified board, int size)
{
if (piece.Y > 1)
{
// left
if (piece.X > 1)
{
piece = CheckDirection(piece, board, -1, -1);
}
// right
if (piece.X < size - 2)
{
piece = CheckDirection(piece, board, 1, -1);
}
}
if (piece.Y < size - 2)
{
// left
if (piece.X > 1)
{
piece = CheckDirection(piece, board, -1, 1);
}
// right
if (piece.X < size - 2)
{
piece = CheckDirection(piece, board, 1, 1);
}
}
return(piece);
}
private (BoardMinified, bool) CheckRule(BoardMinified board)
{
var noNeedToCallNext = false;
var size = board.GetSize();
var activeSetPtr = board.ActivePlayer ? board.Player1Pieces : board.Player2Pieces;
for (var i = 0; i < BoardMinified.BufferSize; i++)
{
var currentPtr = activeSetPtr + i;
var piece = (PieceMinified)(*currentPtr);
if (piece.IsEmpty())
{
break;
}
if (piece.IsCaptured)
{
continue;
}
piece = Check(piece, board, size);
noNeedToCallNext |= piece.HasAvailableMoves();
*currentPtr = piece;
}
return(board, noNeedToCallNext);
}
public void GlobalSetup()
{
_search1 = ServiceLocator.CreateSerialGameTreeSearch();
_search2 = ServiceLocator.CreateDynamicTreeSplittingGameTreeSearch();
_wrapper1 = ServiceLocator.CreateProgressiveDeepeningWrapper(_search1);
_wrapper2 = ServiceLocator.CreateProgressiveDeepeningWrapper(_search2);
var sourceBoardStr = new[]
{
"_b_b_b",
"b_b_b_",
"______",
"______",
"_w_w_w",
"w_w_w_"
};
var sourceBoard1 = new BoardMock(sourceBoardStr, 6, false);
var sourceBoard2 = new BoardMock(sourceBoardStr, 6, false);
_practiceBoard1 = sourceBoard1.ToMinified();
_practiceBoard2 = sourceBoard2.ToMinified();
_cts = new CancellationTokenSource();
_node1 = new GameNode();
_node2 = new GameNode();
}
public override BoardMinified UndoRule(BoardMinified board, HistoryItemMinified toUndo,
HistoryItemMinified lastMoveBeforeUndo)
{
if (
lastMoveBeforeUndo != null &&
toUndo.IsKill &&
lastMoveBeforeUndo.IsKill &&
toUndo.Player == lastMoveBeforeUndo.Player)
{
var piece = board.GetPiece(toUndo.From.X, toUndo.From.Y, toUndo.Player);
piece.ClearMoves();
var newPiece = NeedToCaptureRule.Check(piece, board, board.GetSize());
if (newPiece.HasAvailableMoves())
{
board.ClearMoves();
board.UpdatePieceAvailableMoves(newPiece, toUndo.Player);
if (board.ActivePlayer != lastMoveBeforeUndo.Player)
{
board.SwitchPlayers();
}
return(board);
}
}
return(NextUndo(board, toUndo, lastMoveBeforeUndo));
}
protected BoardMinified Next(BoardMinified board, HistoryItemMinified latestMove)
{
if (NextRule != null)
{
return(NextRule.ApplyRule(board, latestMove));
}
return(board);
}
protected BoardMinified NextUndo(BoardMinified board, HistoryItemMinified toUndo,
HistoryItemMinified lastMoveBeforeUndo)
{
if (NextRule != null)
{
return(NextRule.UndoRule(board, toUndo, lastMoveBeforeUndo));
}
return(board);
}
public PieceMinified Check(PieceMinified piece, BoardMinified board, sbyte directionDown, sbyte directionRight)
{
var boardCell = board.GetBoardCell((byte)(piece.X + directionRight), (byte)(piece.Y + directionDown));
if (boardCell.IsEmpty())
{
piece.AddAvailableMove(directionRight, directionDown, false);
}
return(piece);
}
public override BoardMinified UndoRule(BoardMinified board, HistoryItemMinified toUndo,
HistoryItemMinified lastMoveBeforeUndo)
{
if (board.ActivePlayer != toUndo.Player)
{
board.SwitchPlayers();
}
return(NextUndo(board, toUndo, lastMoveBeforeUndo));
}
public override BoardMinified UndoRule(BoardMinified board, HistoryItemMinified toUndo,
HistoryItemMinified lastMoveBeforeUndo)
{
if (toUndo.IsKill)
{
var captured = toUndo.Captured;
board.RestorePiece(captured, !toUndo.Player);
}
return(NextUndo(board, toUndo, lastMoveBeforeUndo));
}
public override BoardMinified ApplyRule(BoardMinified board, HistoryItemMinified latestMove)
{
board.ClearMoves();
var(newBoard, noNeedToCallNext) = CheckRule(board);
if (!noNeedToCallNext)
{
return(Next(newBoard, latestMove));
}
return(newBoard);
}
public override BoardMinified ApplyRule(BoardMinified board, HistoryItemMinified latestMove)
{
var size = board.GetSize();
var player1Figures = new PieceMinified[20];
var player2Figures = new PieceMinified[20];
if (size < 4)
{
throw new NotImplementedException("Game size smaller than 4");
}
// todo - refactor this
var isWhite = true;
byte i = 0;
for (var y = (byte)(size - 1); y > size / 2; y--)
{
var startX = (byte)(1 - y % 2);
for (var x = startX; x < size; x += 2)
{
var piece = new PieceMinified(x, y, isWhite, true, false);
player1Figures[i] = piece;
board.SetBoardCell(x, y, new BoardCell(i, isWhite));
i++;
}
}
i = 0;
for (byte y = 0; y < size / 2 - 1; y++)
{
var startX = (byte)(1 - y % 2);
for (var x = startX; x < size; x += 2)
{
var piece = new PieceMinified(x, y, !isWhite, false, true);
player2Figures[i] = piece;
board.SetBoardCell(x, y, new BoardCell(i, isWhite));
i++;
}
}
for (byte j = 0; j < player1Figures.Length; j++)
{
board.Player1Pieces[j] = player1Figures[j];
}
for (byte j = 0; j < player2Figures.Length; j++)
{
board.Player2Pieces[j] = player2Figures[j];
}
return(Next(board, null));
}
private BoardMinified CheckRule(BoardMinified board, HistoryItemMinified latestMove)
{
var size = board.GetSize();
var activeSetPtr = board.ActivePlayer ? board.Player1Pieces : board.Player2Pieces;
for (var i = 0; i < BoardMinified.BufferSize; i++)
{
var currentPtr = activeSetPtr + i;
var piece = (PieceMinified)(*currentPtr);
if (piece.IsEmpty())
{
break;
}
if (piece.IsCaptured)
{
continue;
}
if (piece.CanGoUp && piece.Y > 0)
{
//left
if (piece.X > 0)
{
piece = Check(piece, board, -1, -1);
}
//right
if (piece.X < size - 1)
{
piece = Check(piece, board, -1, 1);
}
}
if (piece.CanGoDown && piece.Y < size - 1)
{
//left
if (piece.X > 0)
{
piece = Check(piece, board, 1, -1);
}
//right
if (piece.X < size - 1)
{
piece = Check(piece, board, 1, 1);
}
}
*currentPtr = piece;
}
return(board);
}
public override BoardMinified UndoRule(BoardMinified board, HistoryItemMinified toUndo,
HistoryItemMinified lastMoveBeforeUndo)
{
board.ClearMoves();
var(newBoard, noNeedToCallNext) = CheckRule(board);
if (!noNeedToCallNext)
{
return(NextUndo(newBoard, toUndo, lastMoveBeforeUndo));
}
return(newBoard);
}
public override BoardMinified ApplyRule(BoardMinified board, HistoryItemMinified latestMove)
{
if (latestMove.IsKill)
{
var capturedPieceX = (latestMove.From.X + latestMove.To.X) / 2;
var capturedPieceY = (latestMove.From.Y + latestMove.To.Y) / 2;
latestMove.Captured =
board.RemovePiece((byte)capturedPieceX, (byte)capturedPieceY, !board.ActivePlayer);
}
return(Next(board, latestMove));
}
private static PieceMinified CheckDirection(PieceMinified piece, BoardMinified board, sbyte directionRight,
sbyte directionDown)
{
var target = board.GetBoardCell((byte)(piece.X + directionRight), (byte)(piece.Y + directionDown));
if (!target.IsEmpty() && target.IsWhite() != piece.IsWhite)
{
var second = board.GetBoardCell((byte)(piece.X + 2 * directionRight),
(byte)(piece.Y + 2 * directionDown));
if (second.IsEmpty())
{
piece.AddAvailableMove(directionRight, directionDown, true);
}
}
return(piece);
}
internal static BoardMinified CreateSampleBoard()
{
var board = new BoardMinified(4);
board.Player1Pieces[0] = new PieceMinified(0, 3, true, true, false, false);
board.Player1Pieces[1] = new PieceMinified(3, 2, true, true, false, false);
board.Player2Pieces[0] = new PieceMinified(1, 0, true, true, false, false);
board.SetBoardCell(1, 0, new BoardCell(0, false));
board.SetBoardCell(0, 3, new BoardCell(0, true));
board.SetBoardCell(3, 2, new BoardCell(1, true));
board.Player1PiecesCount = 2;
board.Player2PiecesCount = 1;
return(board);
}
public override BoardMinified ApplyRule(BoardMinified board, HistoryItemMinified latestMove)
{
if (latestMove.IsKill)
{
var piece = board.GetPiece(latestMove.To.X, latestMove.To.Y, latestMove.Player);
piece.ClearMoves();
var newPiece = NeedToCaptureRule.Check(piece, board, board.GetSize());
if (newPiece.HasAvailableMoves())
{
board.ClearMoves();
board.UpdatePieceAvailableMoves(newPiece, board.ActivePlayer);
return(board);
}
}
return(Next(board, latestMove));
}
public override BoardMinified UndoRule(BoardMinified board, HistoryItemMinified toUndo,
HistoryItemMinified lastMoveBeforeUndo)
{
if (toUndo.IsPieceChangeType)
{
var piece = board.GetPiece(toUndo.From.X, toUndo.From.Y, toUndo.Player);
piece.IsQueen = false;
if (toUndo.To.Y > toUndo.From.Y)
{
board.ChangePieceType(piece.X, piece.Y, true, false, false, toUndo.Player);
}
else
{
board.ChangePieceType(piece.X, piece.Y, false, true, false, toUndo.Player);
}
}
return(NextUndo(board, toUndo, lastMoveBeforeUndo));
}
public override BoardMinified ApplyRule(BoardMinified board, HistoryItemMinified latestMove)
{
var x = latestMove.To.X;
var y = latestMove.To.Y;
var piece = board.GetPiece(x, y, latestMove.Player);
if (!piece.IsQueen)
{
var v1 = piece.CanGoDown && y == board.GetSize() - 1;
var v2 = piece.CanGoUp && y == 0;
if (v1 || v2)
{
board.ChangePieceType(x, y, true, true, true, board.ActivePlayer);
latestMove.IsPieceChangeType = true;
}
}
return(Next(board, latestMove));
}
internal BoardMinified UndoMove(BoardMinified board, HistoryItemMinified move, HistoryItemMinified undoMove)
{
return(ChainOfRules.UndoRule(board, move, undoMove));
}
public override BoardMinified ApplyRule(BoardMinified board, HistoryItemMinified latestMove)
{
board = CheckRule(board, latestMove);
return(Next(board, latestMove));
}
internal BoardMinified FastForwardAvailableMoves(BoardMinified board)
{
return(FastForwardAvailableMovesRules.ApplyRule(board, null));
}
public override BoardMinified UndoRule(BoardMinified board, HistoryItemMinified toUndo,
HistoryItemMinified lastMoveBeforeUndo)
{
board = CheckRule(board, toUndo);
return(NextUndo(board, toUndo, lastMoveBeforeUndo));
}
internal BoardMinified FastForwardMove(BoardMinified board, HistoryItemMinified move)
{
return(FastForwardMoveRules.ApplyRule(board, move));
}
public abstract BoardMinified ApplyRule(BoardMinified board, HistoryItemMinified move);
internal BoardMinified FastForwardUndoMove(BoardMinified board, HistoryItemMinified move,
HistoryItemMinified undoMove)
{
return(FastForwardUndoMoveRules.UndoRule(board, move, undoMove));
}
public abstract BoardMinified UndoRule(BoardMinified board, HistoryItemMinified toUndo,
HistoryItemMinified lastMoveBeforeUndo);
public override BoardMinified ApplyRule(BoardMinified board, HistoryItemMinified latestMove)
{
board.MovePiece(latestMove.From.X, latestMove.From.Y, latestMove.To.X, latestMove.To.Y, board.ActivePlayer);
return(Next(board, latestMove));
}
public override BoardMinified UndoRule(BoardMinified board, HistoryItemMinified toUndo,
HistoryItemMinified lastMoveBeforeUndo)
{
board.MovePiece(toUndo.To.X, toUndo.To.Y, toUndo.From.X, toUndo.From.Y, toUndo.Player);
return(NextUndo(board, toUndo, lastMoveBeforeUndo));
}
public override BoardMinified UndoRule(BoardMinified board, HistoryItemMinified toUndo,
HistoryItemMinified lastMoveBeforeUndo)
{
throw new InvalidOperationException();
}
