private static bool PathIsBlocked(BoardMove move, IReadOnlyBoardState <ChessPieceEntity> boardState)
{
if (boardState.IsEmpty(move.To))
{
return(false);
}
var movePlayerColour = boardState.GetItem(move.From)?.Item.Player;
var takeEntity = boardState.GetItem(move.To)?.Item;
var moveIsATake = takeEntity != null && takeEntity.Player != movePlayerColour;
return(moveIsATake);
}
public bool IsPathBetweenClear(BoardMove move, IReadOnlyBoardState <ChessPieceEntity> roBoardState,
Colours kingColour, out IEnumerable <BoardLocation> pathBetween)
{
pathBetween = CalcPathBetweenKingAndCastle(move, kingColour);
return(pathBetween.All(loc
=> roBoardState.GetItem(loc) == null));
}
public bool ValidateMove(BoardMove move, IReadOnlyBoardState <TEntity> roBoardState)
{
var sourcePiece = roBoardState.GetItem(move.From);
if (sourcePiece == null)
{
return(false);
}
var destinationPiece = roBoardState.GetItem(move.To);
if (destinationPiece == null)
{
return(false);
}
return(sourcePiece.Item.Owner != destinationPiece.Item.Owner);
}
private BoardMove FindCastleMove(StandardAlgebraicNotation san, Colours forPlayer)
{
var king = _boardState.GetItem(King.StartPositionFor(forPlayer));
if (king == null)
{
Throw.MoveNotFound($"King not found: {san.ToNotation()}");
}
var y = forPlayer == Colours.White ? 1 : 8;
var from = BoardLocation.At(san.FromFileX.Value, y);
var to = BoardLocation.At(san.ToFileX, y);
var move = king.Paths.FindMove(@from, to);
if (move == null)
{
Throw.MoveNotFound($"No valid castle move found: {from}{to}");
}
return(move);
}
public bool IsFriendlyPawnValidForEnpassant(BoardMove move,
IReadOnlyBoardState <ChessPieceEntity> roBoardState,
out ChessPieceEntity pawn)
{
pawn = null;
var pawnItem = roBoardState.GetItem(move.From);
if (pawnItem == null)
{
return(false);
}
pawn = pawnItem.Item;
return(pawnItem.Item.Is(ChessPieceName.Pawn));
}
public bool IsEnemyPawnValidForEnpassant(BoardMove move,
IReadOnlyBoardState <ChessPieceEntity> roBoardState, Colours attackingPlayer)
{
var passingPieceLocation = move.To.MoveBack(attackingPlayer);
var enemyPawn = roBoardState.GetItem(passingPieceLocation)?.Item as PawnEntity;
if (enemyPawn == null)
{
return(false);
}
return(enemyPawn.TwoStep);
// if (!enemyPawn.Item.Is(attackingPlayer.Enemy(), ChessPieceName.Pawn)) return false;
//
// return enemyPawn.Item.LocationHistory.Count() == 2;
}
public bool IsRookAllowedToCastle(BoardMove move,
IReadOnlyBoardState <ChessPieceEntity> roBoardState, Colours player)
{
var rookLoc = move.MoveType == (int)ChessMoveTypes.CastleKingSide
? $"H{move.From.Y}".ToBoardLocation()
: $"A{move.From.Y}".ToBoardLocation();
var rook = roBoardState.GetItem(rookLoc);
if (rook == null)
{
return(false);
}
return(rook.Item.Is(player, ChessPieceName.Rook) &&
rook.Item.LocationHistory.Count() == 1);
}
public bool IsKingAllowedToCastle(BoardMove move,
IReadOnlyBoardState <ChessPieceEntity> roBoardState,
out ChessPieceEntity king)
{
var kingItem = roBoardState.GetItem(move.From);
king = null;
if (kingItem == null)
{
return(false);
}
king = kingItem.Item;
return(king.Piece.Equals(ChessPieceName.King) &&
kingItem.Location.Equals(Pieces.King
.StartPositionFor(king.Player)) &&
king.LocationHistory.Count() == 1);
}
public bool ValidateMove(BoardMove move, IReadOnlyBoardState <TEntity> roBoardState)
{
var piece = roBoardState.GetItem(move.From);
if (piece == null)
{
return(false);
}
var owner = piece.Item.Owner;
var enemyPaths = new Paths();
var enemyItems = roBoardState.GetItems().Where(i => i.Item.Owner != owner);
enemyPaths.AddRange(enemyItems.SelectMany(li => li.Paths));
var attackMoveTypes = new [] { (int)DefaultActions.MoveOrTake, (int)DefaultActions.TakeOnly, (int)ChessMoveTypes.KingMove };
return(!enemyPaths.ContainsMoveTypeTo(move.To, attackMoveTypes));
}
public bool ValidateMove(BoardMove move, IReadOnlyBoardState <TEntity> roBoardState)
{
var piece = roBoardState.GetItem(move.From);
if (piece == null)
{
return(false);
}
bool valid = false;
if (move.MoveType == (int)DefaultActions.UpdatePieceWithTake)
{
valid = new DestinationContainsEnemyMoveValidator <TEntity>()
.ValidateMove(move, roBoardState);
}
else
{
valid = new DestinationIsEmptyValidator <TEntity>()
.ValidateMove(move, roBoardState);
}
return(valid);
}
public bool IsLocationEmpty(BoardLocation location, IReadOnlyBoardState <ChessPieceEntity> roBoardState) => roBoardState.GetItem(location) == null;
public bool ValidateMove(BoardMove move, IReadOnlyBoardState <TEntity> roBoardState) => roBoardState.GetItem(move.To) == null;
