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