/// <summary>
/// In the future, I should be passing back all the moves rather than a boolean
/// that way the engine can have metadata about all the possible moves that
/// could be taken and maybe offer a suggestion.
/// </summary>
/// <param name="attacksOnKing"></param>
/// <param name="teamAttacks"></param>
/// <returns></returns>
private bool interpositionsExist(IEnumerable <AttackedSquare> attacksOnKing, IEnumerable <AttackedSquare> teamAttacks)
{
foreach (var attackOnKing in attacksOnKing)
{
var attackIsOrthogonal = GeneralEngine.IsOrthogonal(attackOnKing.AttackingSquare.Index, attackOnKing.Index);
var attackIsDiagonal = DiagonalEngine.IsDiagonal(attackOnKing.AttackingSquare.Index, attackOnKing.Index);
var range = new List <Square>();
if (attackIsOrthogonal)
{
var isRankMove = GeneralEngine.GivenOrthogonalMove_IsItARankMove(attackOnKing.AttackingSquare.Index, attackOnKing.Index);
var oxs = getEntireOrthogonalLine(isRankMove, attackOnKing, true);
var ixs = teamAttacks.Select(a => a.Index).Intersect(oxs);
if (ixs.Any())
{
return(true);
}
}
else if (attackIsDiagonal)
{
var dxs = DiagonalEngine.GetDiagonalLine(attackOnKing.AttackingSquare.Index, attackOnKing.Index);
//if dxs contains the clearMove.Index, then the king has not moved out of check
var ixs = teamAttacks.Select(a => a.Index).Intersect(dxs);
if (ixs.Any())
{
return(true);
}
}
//else it could be a knight attack, but no interpositions would exist
}
return(false);
}
private bool mayKingMoveDiagonallyHere(AttackedSquare clearMove, IEnumerable <AttackedSquare> attacksOnKing, List <AttackedSquare> attacks)
{
var kingSquare = (Square)attacksOnKing.First();
//need to detect if we're moving into check
var anybodyAttackingThisSquare = attacks.Any(a => a.Index == clearMove.Index && a.AttackingSquare.Piece.Color != kingSquare.Piece.Color);
if (anybodyAttackingThisSquare)
{
return(false);
}
var diagonalAttacksOnKing = attacksOnKing.Where(a =>
diagonalAttackers.Contains(a.AttackingSquare.Piece.PieceType) &&
DiagonalEngine.IsDiagonal(a.Index, a.AttackingSquare.Index)
);
if (!diagonalAttacksOnKing.Any())
{
return(true);
}
foreach (var x in diagonalAttacksOnKing)
{
var dxs = DiagonalEngine.GetDiagonalLine(x.Index, x.AttackingSquare.Index);
//if dxs contains the clearMove.Index, then the king has not moved out of check
if (dxs.Contains(clearMove.Index))
{
return(false);
}
}
return(true);
}
private void getPieceAttacks(GameState gameState, Square square, List <AttackedSquare> accumulator)
{
switch (square.Piece.PieceType)
{
case PieceType.Pawn:
getPawnAttacks(gameState, square, accumulator);
break;
case PieceType.Knight:
getKnightAttacks(gameState, square, accumulator);
break;
case PieceType.Bishop:
DiagonalEngine.GetDiagonals(gameState, square, accumulator);
break;
case PieceType.Rook:
this._orthogonalService.GetOrthogonals(gameState, square, accumulator);
break;
case PieceType.Queen:
this._orthogonalService.GetOrthogonals(gameState, square, accumulator);
DiagonalEngine.GetDiagonals(gameState, square, accumulator);
break;
case PieceType.King:
getKingAttacks(gameState, square, accumulator);
break;
default:
throw new Exception("Mismatched Enum!");
}
}
public void IsDiagonal()
{
Assert.IsTrue(DiagonalEngine.IsDiagonal(9, 27));
Assert.IsTrue(DiagonalEngine.IsDiagonal(27, 9));
Assert.IsTrue(DiagonalEngine.IsDiagonal(49, 35));
Assert.IsTrue(DiagonalEngine.IsDiagonal(35, 49));
Assert.IsFalse(DiagonalEngine.IsDiagonal(0, 7));
Assert.IsFalse(DiagonalEngine.IsDiagonal(7, 0));
}
public void GetEntireDiagonalByPosition()
{
var list = DiagonalEngine.GetEntireDiagonalByPosition(35);
var accepted = new List <int> {
8, 17, 26, 35, 44, 53, 62, 56, 49, 42, 28, 21, 14, 7
};
var remaining = accepted.Except(list);
Assert.IsFalse(remaining.Any());
}
//public bool IsCheckmate(GameState gameState, Square enemyKingPosition, IEnumerable<AttackedSquare> whiteAttacks, IEnumerable<AttackedSquare> blackAttacks) {
// var activeColor = gameState.ActiveColor;
// var squares = gameState.Squares;
// var checkedColor = gameState.ActiveColor == Color.White ? Color.White : Color.Black; //trust me this is right
// var kingIsBeingAttacked = whiteAttacks.Any(a => a.Index == enemyKingPosition.Index) || blackAttacks.Any(a => a.Index == enemyKingPosition.Index);
// if (!kingIsBeingAttacked) {
// return false;
// }
// //make sure that he cannot move
// var kingHasEscape = false;
public bool IsValidPawnMove(Square currentSquare, List <Square> squares, Color color, int piecePosition, int newPiecePosition, bool isEnPassant)
{
var isDiagonalMove = DiagonalEngine.IsDiagonal(currentSquare.Index, newPiecePosition);
if (!isDiagonalMove)
{
return(true);
}
var pieceToCapture = squares.GetSquare(newPiecePosition).Piece;
var isCapture = pieceToCapture != null;
return(isCapture || isEnPassant);
}
private void testDiagonalLine(int file, DiagonalDirectionFromFileNumber direction, List <int> squares)
{
var diagonalLine = DiagonalEngine.GetEntireDiagonalByFile(_gameState, file, direction);
TestUtility.ListContainsSquares(diagonalLine, squares);
}
