public Path ValidatePath(IReadOnlyBoardState <ChessPieceEntity> boardState, Path possiblePath)
{
var validPath = new Path();
// TODO: Not happy with algorithm, those breaks :(
foreach (var move in possiblePath)
{
if (!_validationProvider.TryGetValue(move.MoveType, out var moveTests))
{
Throw.UnsupportedMoveType(move.MoveType);
}
if (!moveTests.All(t => t(move, boardState)))
{
break;
}
validPath.Add(move);
if (PathIsBlocked(move, boardState))
{
break;
}
}
return(validPath);
}
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 IsPathClearFromAttacks(BoardMove move, IReadOnlyBoardState <ChessPieceEntity> roBoardState, IEnumerable <BoardLocation> pathBetween)
{
// TODO: Use IsLocationUnderAttack() (see above) instead of the the validator
var destinationNotUnderAttackValidator = new DestinationNotUnderAttackValidator <ChessPieceEntity>();
var pathNotUnderAttack = pathBetween.All(loc
=> destinationNotUnderAttackValidator.ValidateMove(
new BoardMove(move.From, loc, (int)DefaultActions.MoveOnly),
roBoardState));
return(pathNotUnderAttack);
}
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 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 ValidateMove(BoardMove move, IReadOnlyBoardState <ChessPieceEntity> roBoardState)
{
if (!_validationSteps.IsLocationEmpty(move.To, roBoardState))
{
return(false);
}
if (!_validationSteps.IsFriendlyPawnValidForEnpassant(move, roBoardState, out var pawn))
{
return(false);
}
var isEnemyPawnValidForEnpassant = _validationSteps.IsEnemyPawnValidForEnpassant(move, roBoardState, pawn.Player);
return(isEnemyPawnValidForEnpassant);
}
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 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);
}
public bool ValidateMove(BoardMove move, IReadOnlyBoardState <ChessPieceEntity> roBoardState)
{
if (!_validationSteps.IsKingAllowedToCastle(move, roBoardState, out var king))
{
return(false);
}
if (!_validationSteps.IsRookAllowedToCastle(move, roBoardState, king.Player))
{
return(false);
}
if (!_validationSteps.IsPathBetweenClear(move, roBoardState, king.Player, out var pathBetween))
{
return(false);
}
return(_validationSteps.IsPathClearFromAttacks(move, roBoardState, pathBetween));
}
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;
public bool ValidateMove(BoardMove move, IReadOnlyBoardState <TEntity> roBoardState)
{
return(new DestinationIsEmptyValidator <TEntity>().ValidateMove(move, roBoardState) ||
new DestinationContainsEnemyMoveValidator <TEntity>().ValidateMove(move, roBoardState));
}
public SanMoveFinder(IReadOnlyBoardState <ChessPieceEntity> boardState)
{
_boardState = boardState;
}
