private AIResponse HandleRegularMove(IChessboard chessboard)
{
var boxesWithPieces = ChessboardBoxesHelper.GetBoxesThatHavePieces(chessboard, Turn);
if (boxesWithPieces.Count == 0)
{
return(AIResponse.NoPiecesLeft);
}
var allAvailableMoves = new List <Tuple <Box, Box> >();
foreach (var boxWithPiece in boxesWithPieces)
{
var availableMoves = GetAvailableMovesFromBox(chessboard, boxWithPiece);
allAvailableMoves.AddRange(availableMoves);
}
if (allAvailableMoves.Count == 0)
{
return(AIResponse.NoMovesLeft);
}
var move = ChooseMove(allAvailableMoves);
chessboard.Move(move.Item1.Position, move.Item2.Position);
return(AIResponse.SuccessfulMove);
}
protected ViewModelBase(ISettingsService settingsService, IDialogCoordinator dialogCoordinator, IChessboard chessboard)
{
SettingsService = settingsService;
DialogCoordinator = dialogCoordinator;
Chessboard = chessboard;
Load();
}
public static bool ChessPieceExistsInSouthEast <T>(this IChessboard chessboard, Position position, PieceColor pieceColor) where T : ChessPiece
{
for (int secondaryRow = position.Row, secondaryColumn = position.Column; secondaryRow >= 1 && secondaryColumn <= 8; secondaryRow--, secondaryColumn++)
{
if (secondaryRow == position.Row && secondaryColumn == position.Column)
{
continue;
}
var locationToBeInspected = chessboard[secondaryRow, secondaryColumn];
var containsPiece = Utilities.LocationContainsPiece <T>(locationToBeInspected, pieceColor);
if (containsPiece)
{
return(true);
}
if (locationToBeInspected.Piece != null)
{
break;
}
}
return(false);
}
public override void CheckPossibilitiesForProvidedLocationAndMarkThem(IChessboard chessBoard, Position position)
{
var row = position.Row;
var column = position.Column;
var startingRow = GetStartingRow();
var forwardOffset = GetForwardOffset();
var positionForward = new Position(row + forwardOffset, column);
var positionForwardWest = new Position(row + forwardOffset, column - 1);
var positionForwardEast = new Position(row + forwardOffset, column + 1);
var positionForwardForward = new Position(row + forwardOffset * 2, column);
if (!positionForward.IsOutOfBounds() && chessBoard[positionForward].Piece == null)
{
ChessboardAccessibleBoxesHelper.MarkIfAccessible(chessBoard, position, positionForward);
}
if (!positionForwardWest.IsOutOfBounds() && chessBoard[positionForwardWest].Piece != null)
{
ChessboardAccessibleBoxesHelper.MarkIfAccessible(chessBoard, position, positionForwardWest);
}
if (!positionForwardEast.IsOutOfBounds() && chessBoard[positionForwardEast].Piece != null)
{
ChessboardAccessibleBoxesHelper.MarkIfAccessible(chessBoard, position, positionForwardEast);
}
if (row == startingRow && !positionForwardForward.IsOutOfBounds() && chessBoard[positionForward].Piece == null && chessBoard[positionForwardForward].Piece == null)
{
ChessboardAccessibleBoxesHelper.MarkIfAccessible(chessBoard, position, positionForwardForward);
}
}
public override void CheckPossibilitiesForProvidedLocationAndMarkThem(IChessboard chessBoard, Position position)
{
var kingPosition = chessBoard[position].Piece.Color == PieceColor.White
? chessBoard.PositionWhiteKing
: chessBoard.PositionBlackKing;
var positionNorth = new Position(kingPosition.Row, kingPosition.Column + 1);
var positionSouth = new Position(kingPosition.Row, kingPosition.Column - 1);
var positionWest = new Position(kingPosition.Row - 1, kingPosition.Column);
var positionEast = new Position(kingPosition.Row + 1, kingPosition.Column);
var positionNorthWest = new Position(kingPosition.Row - 1, kingPosition.Column + 1);
var positionNorthEast = new Position(kingPosition.Row + 1, kingPosition.Column + 1);
var positionSouthWest = new Position(kingPosition.Row - 1, kingPosition.Column - 1);
var positionSouthEast = new Position(kingPosition.Row + 1, kingPosition.Column - 1);
MarkPositionIfAllowed(chessBoard, kingPosition, positionNorth);
MarkPositionIfAllowed(chessBoard, kingPosition, positionSouth);
MarkPositionIfAllowed(chessBoard, kingPosition, positionWest);
MarkPositionIfAllowed(chessBoard, kingPosition, positionEast);
MarkPositionIfAllowed(chessBoard, kingPosition, positionNorthWest);
MarkPositionIfAllowed(chessBoard, kingPosition, positionNorthEast);
MarkPositionIfAllowed(chessBoard, kingPosition, positionSouthWest);
MarkPositionIfAllowed(chessBoard, kingPosition, positionSouthEast);
}
public override void CheckPossibilitiesForProvidedLocationAndMarkThem(IChessboard chessBoard, Position position)
{
ChessboardAccessibleBoxesHelper.MarkAccessibleBoxesForWest(chessBoard, position);
ChessboardAccessibleBoxesHelper.MarkAccessibleBoxesForEast(chessBoard, position);
ChessboardAccessibleBoxesHelper.MarkAccessibleBoxesForSouth(chessBoard, position);
ChessboardAccessibleBoxesHelper.MarkAccessibleBoxesForNorth(chessBoard, position);
}
public static void MarkIfAccessible(IChessboard chessBoard, Position startPosition, Position destinationPosition)
{
if (destinationPosition.IsOutOfBounds())
{
return;
}
if (chessBoard[destinationPosition].Piece == null)
{
if (!chessBoard.MoveTriggersCheck(startPosition, destinationPosition))
{
chessBoard[destinationPosition].Available = true;
chessBoard[startPosition].Piece.CanMove = true;
}
}
else
{
if (chessBoard[destinationPosition].Piece.Color != chessBoard[startPosition].Piece.Color)
{
if (!chessBoard.MoveTriggersCheck(startPosition, destinationPosition))
{
chessBoard[destinationPosition].Available = true;
chessBoard[startPosition].Piece.CanMove = true;
}
}
}
}
public override void CheckPossibilitiesForProvidedLocationAndMarkThem(IChessboard chessBoard, Position position)
{
var row = position.Row;
var column = position.Column;
var destinationNorthNorthEast = new Position(row + 2, column + 1);
var destinationSouthSouthEast = new Position(row - 2, column + 1);
var destinationNorthEastEast = new Position(row + 1, column + 2);
var destinationSouthEastEast = new Position(row - 1, column + 2);
var destinationNorthNorthWest = new Position(row + 2, column - 1);
var destinationSouthSouthWest = new Position(row - 2, column - 1);
var destinationNorthWestWest = new Position(row + 1, column - 2);
var destinationSouthWestWest = new Position(row - 1, column - 2);
ChessboardAccessibleBoxesHelper.MarkIfAccessible(chessBoard, position, destinationNorthNorthEast);
ChessboardAccessibleBoxesHelper.MarkIfAccessible(chessBoard, position, destinationSouthSouthEast);
ChessboardAccessibleBoxesHelper.MarkIfAccessible(chessBoard, position, destinationNorthEastEast);
ChessboardAccessibleBoxesHelper.MarkIfAccessible(chessBoard, position, destinationSouthEastEast);
ChessboardAccessibleBoxesHelper.MarkIfAccessible(chessBoard, position, destinationNorthNorthWest);
ChessboardAccessibleBoxesHelper.MarkIfAccessible(chessBoard, position, destinationSouthSouthWest);
ChessboardAccessibleBoxesHelper.MarkIfAccessible(chessBoard, position, destinationNorthWestWest);
ChessboardAccessibleBoxesHelper.MarkIfAccessible(chessBoard, position, destinationSouthWestWest);
}
public static bool ChessPieceExistsInNorth <T>(this IChessboard chessboard, Position position, PieceColor pieceColor) where T : ChessPiece
{
for (var secondaryRow = position.Row; secondaryRow <= 8; secondaryRow++)
{
if (secondaryRow == position.Row)
{
continue;
}
var locationToBeInspected = chessboard[secondaryRow, position.Column];
var containsPiece = Utilities.LocationContainsPiece <T>(locationToBeInspected, pieceColor);
if (containsPiece)
{
return(true);
}
if (locationToBeInspected.Piece != null)
{
break;
}
}
return(false);
}
static void Main(string[] args)
{
IChessboard board = ServiceProxy.Create <IChessboard>("3", new Uri("fabric:/MessyChessApplication/Chessboard"));
board.PutAPieceAsync(new ChessPieceInfo {
ActorId = "1", PieceType = ChessPieceType.King, Team = 1, X = 1, Y = 1
}).Wait();
}
private void MarkPositionIfAllowed(IChessboard chessBoard, Position kingPosition, Position newKingPosition)
{
if (IsMovePossible(chessBoard, kingPosition, newKingPosition))
{
chessBoard[newKingPosition].Available = true;
chessBoard[kingPosition].Piece.CanMove = true;
}
}
public void TestThatWhenAiPlayerIsInCheckmatePerformMoveReturnsExpectedResponse()
{
randomMovesAiPlayer.Turn = PieceColor.White;
chessboard = ChessboardProvider.GetChessboardClassicWithProvidedColorInCheckmate(PieceColor.White);
var aiResponse = randomMovesAiPlayer.PerformMove(chessboard);
Assert.AreEqual(AIResponse.NoMovesLeft, aiResponse);
}
private void AddPawns(IPlayer player, IChessboard board, int row)
{
for (int i = 0; i < 8; i++)
{
var pawn = new Pawn(player.Color);
player.AddFigure(pawn);
var position = new Position(row, i);
board.AddFigure(pawn, position);
}
}
private void AddSpecialFigures(IPlayer player, IChessboard board, int row)
{
for (int i = 0; i < figureTypes.Length; i++)
{
var figure = (IFigure)Activator.CreateInstance(figureTypes[i], player.Color);
player.AddFigure(figure);
var position = new Position(row, i);
board.AddFigure(figure, position);
}
}
public override void Validate(IChessboard board, Position from, Position to, ChessColor playerColor)
{
base.Validate(board, from, to, playerColor);
var verticalMoves = Math.Abs(from.Row - to.Row);
var horizontalMoves = Math.Abs(from.Col - to.Col);
if (verticalMoves > 1 || horizontalMoves > 1)
{
throw new InvalidOperationException("King cannot move there");
}
}
private void ValidateStrategy(IList <IPlayer> players, IChessboard board)
{
if (players.Count != 2)
{
throw new InvalidOperationException("This strategy expect two players!");
}
if (board.Rows != 8 || board.Cols != 8)
{
throw new InvalidOperationException("This strategy requires 8 rows and 8 cols");
}
}
public override void Validate(IChessboard board, Position from, Position to, ChessColor playerColor)
{
base.Validate(board, from, to, playerColor);
var enemyFigure = board.GetBoard[to.Row, to.Col];
if (playerColor == ChessColor.White)
{
if (from.Row != 6)
{
if (from.Row - 1 != to.Row)
{
throw new InvalidOperationException("You cannot move this pawn there");
}
}
else
{
if (from.Row - 2 > to.Row)
{
throw new InvalidOperationException("You cannot move this pawn there");
}
}
}
else if (playerColor == ChessColor.Black)
{
if (from.Row != 1)
{
if (from.Row + 1 != to.Row)
{
throw new InvalidOperationException("You cannot move this pawn there");
}
}
else
{
if (from.Row + 2 < to.Row)
{
throw new InvalidOperationException("You cannot move this pawn there");
}
}
}
if (enemyFigure == null && from.Col - to.Col != 0)
{
throw new InvalidOperationException("You cannot move this pawn there");
}
else if (enemyFigure != null && enemyFigure.Color != playerColor && Math.Abs(from.Col - to.Col) != 1)
{
throw new InvalidOperationException("You cannot move this pawn there");
}
base.JumpOverValidate(board, from, to);
}
public void Initialize(IList <IPlayer> players, IChessboard board)
{
this.ValidateStrategy(players, board);
var firstPlayer = players[0];
var secondPlayer = players[1];
this.AddSpecialFigures(firstPlayer, board, 7);
this.AddPawns(firstPlayer, board, 6);
this.AddSpecialFigures(secondPlayer, board, 0);
this.AddPawns(secondPlayer, board, 1);
}
public override void Validate(IChessboard board, Position from, Position to, ChessColor playerColor)
{
base.Validate(board, from, to, playerColor);
var verticalMoves = Math.Abs(from.Row - to.Row);
var horizontalMoves = Math.Abs(from.Col - to.Col);
if (verticalMoves != horizontalMoves && verticalMoves != 0 && horizontalMoves != 0)
{
throw new InvalidOperationException("Queen cannot move there");
}
base.JumpOverValidate(board, from, to);
}
public void TestThatWhenMoveIsAvailableForAiPerformMovePerformsExpectedMoveReturnsExpectedResult()
{
randomMovesAiPlayer.Turn = PieceColor.White;
chessboard = ChessboardProvider.GetChessboardClassicSingleMoveAvailableForProvidedColor(PieceColor.White);
var aiResponse = randomMovesAiPlayer.PerformMove(chessboard);
var expectedMovePosition = new Position(8, 8);
Assert.AreEqual(AIResponse.SuccessfulMove, aiResponse);
Assert.IsNotNull(chessboard[expectedMovePosition].Piece);
Assert.IsTrue(chessboard[expectedMovePosition].Piece is Pawn);
Assert.IsTrue(chessboard[expectedMovePosition].Piece.Color == PieceColor.White);
}
public override void Validate(IChessboard board, Position from, Position to, ChessColor playerColor)
{
base.Validate(board, from, to, playerColor);
var verticalMoves = Math.Abs(from.Row - to.Row);
var horizontalMoves = Math.Abs(from.Col - to.Col);
if ((verticalMoves == 1 && horizontalMoves == 2) || (verticalMoves == 2 && horizontalMoves == 1))
{
return;
}
throw new InvalidOperationException("You cannot move this figure there");
}
public override void Validate(IChessboard board, Position from, Position to, ChessColor playerColor)
{
base.Validate(board, from, to, playerColor);
if ((from.Col != to.Col && from.Row == to.Row) || (from.Col == to.Col && from.Row != to.Row))
{
base.JumpOverValidate(board, from, to);
return;
}
else
{
throw new InvalidOperationException("You cannot move there");
}
}
private bool IsMovePossible(IChessboard chessBoard, Position source, Position destination)
{
if (chessBoard[source] == null || chessBoard[destination] == null)
{
return(false);
}
var isPossible = false;
var locationKingSource = chessBoard[source];
var locationKingDestination = chessBoard[destination];
if (locationKingDestination.Piece != null)
{
if (locationKingDestination.Piece.Color != locationKingSource.Piece.Color)
{
// Pretend the king was moved to the destination
var chessPieceBackup = chessBoard[destination].Piece;
chessBoard[destination].Piece = chessBoard[source].Piece;
chessBoard[source].Piece = null;
if (!IsInCheck(chessBoard, destination))
{
isPossible = true;
}
// Restore states of the king and of the destination
chessBoard[source].Piece = chessBoard[destination].Piece;
chessBoard[destination].Piece = chessPieceBackup;
}
}
else
{
// Pretend the king was moved to the destination
chessBoard[destination].Piece = chessBoard[source].Piece;
chessBoard[source].Piece = null;
if (!IsInCheck(chessBoard, destination))
{
isPossible = true;
}
// Restore states of the king and of the destination
chessBoard[source].Piece = chessBoard[destination].Piece;
chessBoard[destination].Piece = null;
}
return(isPossible);
}
public static int GetNumberOfAvailableBoxes(IChessboard boxes)
{
int counter = 0;
for (int row = 1; row < 9; row++)
{
for (int column = 1; column < 9; column++)
{
if (boxes[row, column].Available)
{
counter++;
}
}
}
return(counter);
}
private static List <Tuple <Box, Box> > GetAvailableMovesFromBox(IChessboard chessboard, Box origin)
{
var moves = new List <Tuple <Box, Box> >();
origin.Piece.CheckPossibilitiesForProvidedLocationAndMarkThem(chessboard, origin.Position);
var availableBoxes = ChessboardBoxesHelper.GetAvailableBoxes(chessboard);
foreach (var availableBox in availableBoxes)
{
moves.Add(new Tuple <Box, Box>(origin, availableBox));
}
chessboard.SetChessboardBoxesAsUnavailable();
return(moves);
}
public void TestThatWhenAiPlayerCanRetakePiecePerformMoveRetakesPieceAndReturnsExpectedResponse()
{
randomMovesAiPlayer.Turn = PieceColor.White;
chessboard = ChessboardProvider.GetChessboardClassicWithProvidedColorAboutToRetakePiece(PieceColor.White, new Rook(PieceColor.White));
var retakenPiecesCountBeforeMove = chessboard.CapturedPieceCollection.GetEntryCount(new Rook(PieceColor.White));
var aiResponse = randomMovesAiPlayer.PerformMove(chessboard);
var retakenPiecesCountAfterMove = chessboard.CapturedPieceCollection.GetEntryCount(new Rook(PieceColor.White));
var expectedRetakePosition = new Position(8, 8);
Assert.AreEqual(AIResponse.SuccessfulMove, aiResponse);
Assert.IsNotNull(chessboard[expectedRetakePosition].Piece);
Assert.IsTrue(chessboard[expectedRetakePosition].Piece is Rook);
Assert.IsTrue(chessboard[expectedRetakePosition].Piece.Color == PieceColor.White);
Assert.AreEqual(retakenPiecesCountAfterMove, retakenPiecesCountBeforeMove - 1);
}
protected void JumpOverValidate(IChessboard board, Position from, Position to)
{
bool reachedRow = false;
bool reachedCol = false;
var remainingRows = from.Row - to.Row;
var remainingCols = from.Col - to.Col;
var destinationRow = to.Row;
var destinationCol = to.Col;
while (!reachedRow || !reachedCol)
{
if (remainingRows != 0)
{
remainingRows = remainingRows > 0 ? remainingRows - 1 : remainingRows + 1;
}
if (remainingCols != 0)
{
remainingCols = remainingCols > 0 ? remainingCols - 1 : remainingCols + 1;
}
if (remainingCols == 0)
{
reachedCol = true;
}
if (remainingRows == 0)
{
reachedRow = true;
}
if (reachedRow && reachedCol)
{
break;
}
var currentFigure = board.GetBoard[destinationRow + remainingRows, destinationCol + remainingCols];
if (currentFigure != null && (!reachedCol || !reachedRow))
{
throw new InvalidOperationException("You cannot step onto a figure");
}
}
}
public static List <Box> GetAvailableBoxes(IChessboard chessboard)
{
var boxes = new List <Box>();
for (var row = 1; row < 9; row++)
{
for (var column = 1; column < 9; column++)
{
var currentBox = chessboard[row, column];
if (currentBox.Available)
{
boxes.Add(currentBox);
}
}
}
return(boxes);
}
public static List <Box> GetBoxesThatHavePieces(IChessboard chessboard, PieceColor pieceColor = PieceColor.Undefined)
{
var boxes = new List <Box>();
for (var row = 1; row < 9; row++)
{
for (var column = 1; column < 9; column++)
{
var currentBox = chessboard[row, column];
if (currentBox.Piece != null && PieceHasDesiredColor(currentBox.Piece, pieceColor))
{
boxes.Add(currentBox);
}
}
}
return(boxes);
}
public AIResponse PerformMove(IChessboard chessboard)
{
if (chessboard.CurrentTurn != Turn)
{
return(AIResponse.NotAIsTurn);
}
Thread.Sleep(BaseWaitTimeInMilliseconds);
var statusAfterRegularMove = HandleRegularMove(chessboard);
if (chessboard.RetakingIsActive)
{
var statusAfterRetaking = HandleRetaking(chessboard);
return(statusAfterRetaking);
}
return(statusAfterRegularMove);
}
