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; }