public CapturedPice(ChessCom.PiceCapture pc)
{
Background = (ChessboardModel.FieldColorLight(pc.Location) ? StyleMirror.WhiteField : StyleMirror.BlackField) ?? new SolidColorBrush(Colors.Pink);
Pice = AssetBank.ImageFromPice(pc.Pice);
Field = pc.Location;
PiceType = pc.Pice;
}
public List <string> CheckQuarter(int xStep, int yStep, Position position, ChessboardModel chessboard, bool addNextStep = true)
{
var possibleMovies = new List <string>();
bool doNextIteration = false;
var colour = chessboard[position].Piece.Colour;
do
{
position.X += xStep;
position.Y += yStep;
TypeOfField typeOfField = chessboard.GetTypeOfField(position);
if (addNextStep)
{
doNextIteration = DoNextIteration(typeOfField);
}
if (IsMovePossible(typeOfField, colour))
{
possibleMovies.Add(position.ToString());
}
}while (doNextIteration);
return(possibleMovies);
}
public void CheckMovies_Few_Possible_Movies_Test()
{
//Arrange
var chessboard = new ChessboardModel(new ChessMovie());
var pieceFactory = new ChessPieceFactory();
chessboard["b3"].Piece = pieceFactory.Create(ColourOfPiece.White, KindOfPiece.Pawn);
chessboard["a4"].Piece = pieceFactory.Create(ColourOfPiece.Black, KindOfPiece.Pawn);
chessboard["d5"].Piece = pieceFactory.Create(ColourOfPiece.Black, KindOfPiece.Pawn);
chessboard["d1"].Piece = pieceFactory.Create(ColourOfPiece.White, KindOfPiece.Pawn);
chessboard["b5"].Piece = pieceFactory.Create(ColourOfPiece.Black, KindOfPiece.Pawn);
chessboard["b1"].Piece = pieceFactory.Create(ColourOfPiece.Black, KindOfPiece.Pawn);
chessboard["e3"].Piece = pieceFactory.Create(ColourOfPiece.White, KindOfPiece.Pawn);
//Act
var receivedMovies = chessboard["b3"].Piece.CheckStrategy.CheckMovies(new Position("b3"), chessboard);
var expectedMovies = new List <string>()
{
"a4", "b4"
};
var commonMovies = receivedMovies.Intersect(expectedMovies);
//Assert
Assert.AreEqual(expectedMovies.Count(), commonMovies.Count());
}
public List <string> CheckMovies(Position position, ChessboardModel chessboard)
{
List <string> possibleMovies = new List <string>();
possibleMovies.AddRange(CheckQuarter(1, 0, position, chessboard));
possibleMovies.AddRange(CheckQuarter(-1, 0, position, chessboard));
possibleMovies.AddRange(CheckQuarter(0, -1, position, chessboard));
possibleMovies.AddRange(CheckQuarter(0, 1, position, chessboard));
return(possibleMovies);
}
public WorkspaceBuilder WithChessboard(string theVisualizerName)
{
if (string.IsNullOrWhiteSpace(theVisualizerName))
{
throw new ArgumentException(nameof(theVisualizerName));
}
var chessboard = new ChessboardModel(new ModelName(theVisualizerName));
var chessboardVisualizer = new ChessboardTabModel(chessboard, new WorkspaceTabTitle());
_workspace.AddVisualizer(chessboardVisualizer);
return(this);
}
public List <string> CheckMovies(Position position, ChessboardModel chessboard)
{
var possibleMovies = new List <string>();
possibleMovies.AddRange(Component.CheckMovies(position, chessboard));
if (IsCastlingPossible(TypeOfCastling.Short, position, chessboard))
{
possibleMovies.Add(new Position(6, position.Y).ToString());
}
return(possibleMovies);
}
public List <string> CheckMovies(Position position, ChessboardModel chessboard)
{
List <string> possibleMovies = new List <string>();
var pieceColour = chessboard[position].Piece.Colour;
if (IsFirstMove)
{
possibleMovies.AddRange(CheckMove(2, position, chessboard));
}
possibleMovies.AddRange(CheckMove(1, position, chessboard));
possibleMovies.AddRange(CheckAttack(1, -1, position, chessboard, pieceColour));
possibleMovies.AddRange(CheckAttack(1, 1, position, chessboard, pieceColour));
return(possibleMovies);
}
public List <string> CheckMovies(Position position, ChessboardModel chessboard)
{
List <string> possibleMovies = new List <string>();
possibleMovies.AddRange(validateMethod.CheckQuarter(1, 2, position, chessboard, false));
possibleMovies.AddRange(validateMethod.CheckQuarter(-1, 2, position, chessboard, false));
possibleMovies.AddRange(validateMethod.CheckQuarter(2, -1, position, chessboard, false));
possibleMovies.AddRange(validateMethod.CheckQuarter(2, 1, position, chessboard, false));
possibleMovies.AddRange(validateMethod.CheckQuarter(-2, 1, position, chessboard, false));
possibleMovies.AddRange(validateMethod.CheckQuarter(-2, -1, position, chessboard, false));
possibleMovies.AddRange(validateMethod.CheckQuarter(-1, -2, position, chessboard, false));
possibleMovies.AddRange(validateMethod.CheckQuarter(1, -2, position, chessboard, false));
return(possibleMovies);
}
public void CheckMovies_Short_Castling_Occupied_Field()
{
//Arrange
var chessboard = new ChessboardModel(new ChessMovie());
var pieceFactory = new ChessPieceFactory();
chessboard["e1"].Piece = pieceFactory.Create(ColourOfPiece.White, KindOfPiece.King);
chessboard["h1"].Piece = pieceFactory.Create(ColourOfPiece.White, KindOfPiece.Rook);
chessboard["a6"].Piece = pieceFactory.Create(ColourOfPiece.Black, KindOfPiece.Bishop);
var castling = new Castling();
//Act
var receivedMovies = castling.CheckMovies(new Position("e1"), chessboard);
//Assert
Assert.AreEqual(receivedMovies.Count(), 0);
}
private List <string> CheckMove(int yStep, Position position, ChessboardModel chessboard)
{
position.Y += yStep;
var typeOfField = chessboard.GetTypeOfField(position);
if (typeOfField == TypeOfField.Empty)
{
return new List <string>()
{
position.ToString()
}
}
;
else
{
return(new List <string>());
}
}
private List <string> CheckAttack(int yStep, int xStep, Position position, ChessboardModel chessboard, ColourOfPiece pieceColour)
{
position.Y += yStep;
position.X += xStep;
var typeOfField = chessboard.GetTypeOfField(position);
if (typeOfField == TypeOfField.BlackPiece && pieceColour == ColourOfPiece.White ||
typeOfField == TypeOfField.WhitePiece && pieceColour == ColourOfPiece.Black)
{
return new List <string>()
{
position.ToString()
}
}
;
else
{
return(new List <string>());
}
}
public void CheckMovies_Short_Castling_Movie_Possible()
{
//Arrange
var chessboard = new ChessboardModel(new ChessMovie());
var pieceFactory = new ChessPieceFactory();
chessboard["e1"].Piece = pieceFactory.Create(ColourOfPiece.White, KindOfPiece.King);
chessboard["h1"].Piece = pieceFactory.Create(ColourOfPiece.White, KindOfPiece.Rook);
chessboard["a6"].Piece = pieceFactory.Create(ColourOfPiece.White, KindOfPiece.Bishop);
var castling = new Castling();
//Act
var receivedMovies = castling.CheckMovies(new Position("e1"), chessboard);
var expectedMovies = new List <string>()
{
"g1"
};
var commonMovies = receivedMovies.Intersect(expectedMovies);
//Assert
Assert.AreEqual(expectedMovies.Count(), commonMovies.Count());
}
private bool AreCastlingFieldsEmpty(int[] emptyFieldXPositions, Position position, ChessboardModel chessboard)
{
foreach (var positionX in emptyFieldXPositions)
{
if (chessboard.GetTypeOfField(new Position(positionX, position.Y)) != TypeOfField.Empty)
{
return(false);
}
}
return(true);
}
private bool AreCastlingFieldsNotAttacking(int[] attackFieldXPositions, Position position, ChessboardModel chessboard)
{
var colour = chessboard[position].Piece.Colour;
List <string> checkedFields = GetCastlingAttackFields(attackFieldXPositions, position.Y);
for (int i = 0; i < 8; i++)
{
for (int j = 0; j < 8; j++)
{
var attackMovies = new List <string>();
if (chessboard.Fields[i, j].Piece != null &&
chessboard.Fields[i, j].Piece.Colour != colour)
{
attackMovies.AddRange(chessboard[i, j].Piece.CheckStrategy.CheckMovies(new Position(i, j), chessboard));
}
if (!attackMovies.TrueForAll(a => !checkedFields.Contains(a)))
{
return(false);
}
}
}
return(true);
}
protected bool IsCastlingPossible(TypeOfCastling typeOfCastling, Position position, ChessboardModel chessboard)
{
int rookXPosition;
int[] emptyFieldXPositions, attackFieldXPositions;
switch (typeOfCastling)
{
case TypeOfCastling.Long:
rookXPosition = 0;
emptyFieldXPositions = new int[] { 1, 2, 3 };
attackFieldXPositions = new int[] { 2, 3, 4 };
break;
case TypeOfCastling.Short:
rookXPosition = 7;
emptyFieldXPositions = new int[] { 5, 6 };
attackFieldXPositions = new int[] { 4, 5, 6 };
break;
default:
throw new ApplicationException("unexpected argument");
}
return(IsRookExist(rookXPosition, rookYPosition: position.Y, chessboard) &&
AreCastlingFieldsEmpty(emptyFieldXPositions, position, chessboard) &&
AreCastlingFieldsNotAttacking(attackFieldXPositions, position, chessboard));
}
/// <summary>
/// Initialize a chessboard view model with a chessboard model.
/// </summary>
/// <param name="theModel">Chessboard model.</param>
public ChessboardViewModel(ChessboardModel theModel)
{
Model = theModel;
Squares = new ObservableCollection <ChessboardSquareViewModel>();
}
private bool IsRookExist(int rookXPosition, int rookYPosition, ChessboardModel chessboard)
{
var rook = chessboard[rookXPosition, rookYPosition].Piece;
return(rook != null && rook.Kind == KindOfPiece.Rook);
}
public void CheckMoviesTest()
{
var factory = new BoardFactory();
ChessboardModel chessboard =
}
public List <string> CheckMovies(Position position, ChessboardModel chessboard)
{
return(Component.CheckMovies(position, chessboard));
}
