/// <summary> /// Returns whether the piece has any possible legal captures. /// </summary> /// <param name="piece"></param> /// <returns></returns> private bool DoesPieceHaveLegalCapture(IPiece piece) { piece.GenerateCaptures(GameBoard.State, ActivePlayerBoardState); ICapture capture = ModelLocator.Capture; capture.StartingPosition = piece.Location; IBoardState captureSet = ModelLocator.BoardState; captureSet.Add(piece.CaptureSet); foreach (ChessPosition position in captureSet) { capture.EndingPosition = position; if (IsCaptureLegal(piece, capture, GameBoard.State)) { return(true); } if (piece is IPawn && IsCaptureLegalEnPassant(piece, capture, GameBoard)) { return(true); } } return(false); }
/// <summary> /// Can any friendly piece block the attacker? /// </summary> /// <param name="threateningPiece"></param> /// <returns></returns> private bool CanFriendlyPieceMoveBetweenKingAndAttacker(IPiece threateningPiece, IBoardState boardState) { switch (threateningPiece) { // all cases fall through case IKnight _: // knights jump pieces, cannot move between case IPawn _: // pawns attack in an adjacent square, cannot move between case IKing _: // king will never be checking another king. return(false); } foreach (IPiece piece in ActivePlayerPieces.Where(p => !(p is IKing) && p.Location != ChessPosition.None)) { piece.GenerateMoves(boardState); // use a copy of the MoveSet to prevent the collection from being modified in the following loop IBoardState copyOfMoveSet = ModelLocator.BoardState; copyOfMoveSet.Add(piece.MoveSet); foreach (ChessPosition location in copyOfMoveSet) { var move = ModelLocator.CreateMove(piece.Location, location); var isMoveLegal = IsMoveLegal(piece, move, boardState); var isKingInCheckAfterMove = DoesPotentialMoveLeaveKingInCheck(move); if (isMoveLegal && !isKingInCheckAfterMove) { return(true); } } } return(false); }
public BoardState(IBoardState boardState) { Fen = boardState.Fen; OriginalPosition = boardState.OriginalPosition; NewPosition = boardState.NewPosition; ETag = boardState.ETag; }
public IEnumerable <IReversiTurn> GetValidTurnsForBoard(IBoardState board) { var turnCandidates = board.GetEmptyEnemyNeighbours(); var result = new List <IReversiTurn>(); foreach (ICellCoordinates cell in turnCandidates) { var turn = this.TurnForCellOnBoard(cell, board); if (null == turn) { continue; } result.Add(turn); } bool isNoValidTurnsLeft = (0 == result.Count); if (isNoValidTurnsLeft) { return(null); } return(result); }
public GameCheckState Check(IBoardState <ChessPieceEntity> boardState) { var whiteState = _playerStateService.CurrentPlayerState(boardState, Colours.White); var blackState = _playerStateService.CurrentPlayerState(boardState, Colours.Black); if (whiteState == PlayerState.None && blackState == PlayerState.None) { return(GameCheckState.None); } if (whiteState != PlayerState.None && blackState != PlayerState.None) { Throw.InvalidGameState($"Invalid game states white/black {whiteState}/{blackState}"); } if (blackState == PlayerState.None) { return(whiteState == PlayerState.Checkmate ? GameCheckState.WhiteCheckmated : GameCheckState.WhiteInCheck); } return(blackState == PlayerState.Checkmate ? GameCheckState.BlackCheckmated : GameCheckState.BlackInCheck); }
/// <summary> /// Creates a board with starting positions. /// </summary> public Board(IBoardState state) { State = state; State.Add(ChessPosition.WhiteStart); State.Add(ChessPosition.BlackStart); }
public void PlayTurn(IBoardState boardState) { LOGIC_START: foreach (Hex own in boardState.GetFieldsForPlayer(this._player)) { if (own.Dices == 1) { continue; } foreach ((Hex other, RelativeDirection direction) in boardState.GetNeighborsOfDifferentColor(this._player.Color, own)) { // 0.33 - 6.0 double diceRelation = ((double)own.Dices) / other.Dices; if ((this._random.NextDouble() * 0.5 + diceRelation > 1.2d || own.Dices == 8) && boardState.CanAttack(own, other, out _)) { bool won = boardState.PerformAttack(own, other).victory; if (won) { // Restart the logic to also process the freshly conquered fields goto LOGIC_START; } else { break; } } } } }
public void PlayTurn(IBoardState boardState) { Color lastAttackedBy = boardState.AttackHistory.LastOrDefault(x => x.defender.playerColor == this._player.Color).attacker.playerColor; LOGIC_START: foreach (Hex own in boardState.GetFieldsForPlayer(this._player)) { if (own.Dices == 1) { continue; } foreach ((Hex other, RelativeDirection direction) in boardState.GetNeighborsOfColor(lastAttackedBy, own)) { if (own.Dices >= other.Dices && boardState.CanAttack(own, other, out _)) { bool won = boardState.PerformAttack(own, other).victory; if (won) { // Restart the logic to also process the freshly conquered fields goto LOGIC_START; } else { break; } } } } }
public void ChangeState(BoardState state) { _currentState?.OnExitState(); _currentState = _states[(int)state]; CurrentState.Value = state; _currentState.OnEnterState(); }
/// <summary> /// Adds a capture to the capture set. /// </summary> /// <param name="capturePosition"></param> /// <param name="enemyBoardState"></param> protected void AddCaptureToCaptureSet(ChessPosition capturePosition, IBoardState enemyBoardState) { if (enemyBoardState.Contains(capturePosition)) { CaptureSet.Add(capturePosition); } }
public PlayerIIMoved(IBoardState boardState) { Fen = boardState.Fen; OriginalPosition = boardState.OriginalPosition; NewPosition = boardState.NewPosition; ETag = boardState.ETag; }
public override void GenerateMoves(IBoardState boardState) { foreach (var move in TestMoves) { MoveSet.Add(move); } }
private void RefreshPathsFeature(IBoardState <ChessPieceEntity> boardState, Colours currentPlayer) { if (FeatureFlags.CachingPaths) { // Need proper boardstate key I think, currently a few tests fail, I guess around some state related // so something not encoded in the textboard (enpassant and castle viability namely) var stateKey = ChessGameConvert.SerialiseBoard(boardState); if (_stateCache.TryGetValue(stateKey, out var items)) { boardState.UpdatePaths(items); } else { RefreshChessPaths(boardState, currentPlayer); if (FeatureFlags.CachingPaths) { _stateCache.Add(stateKey, boardState.GetItems().ToArray()); } } } else { RefreshChessPaths(boardState, currentPlayer); } }
public override void GenerateCaptures(IBoardState boardState, IBoardState owningPlayerBoardState) { foreach (var capture in TestCaptures) { CaptureSet.Add(capture); } }
static async Task UserInputHandler(ISourceBlock <UserInputEvent> source) { // Read from the source buffer until the source buffer has no // available output data. while (await source.OutputAvailableAsync()) { var input = source.Receive(); if (input == UserInputEvent.ButtonPress) { if (boardState == clock) { boardState = countdown; } else { boardState = clock; } } if (input == UserInputEvent.RotateRight && boardState == countdown) { countdown.Increase(); } else if (input == UserInputEvent.RotateLeft && boardState == countdown) { countdown.Decrease(); } } }
/// <summary> /// Generates all legal <see cref="IPawn" /> moves /// </summary> /// <param name="boardState"></param> public override void GenerateMoves(IBoardState boardState) { IChessPieceMover cpm = ModelLocator.ChessPieceMover; MoveSet.Clear(); ChessPosition oneSpaceFromLocation = Color == ChessColor.White ? cpm.North(Location) : cpm.South(Location); bool oneSpaceMoveIsLegal = !boardState.Contains(oneSpaceFromLocation); if (oneSpaceMoveIsLegal) { MoveSet.Add(oneSpaceFromLocation); } else { return; } ChessPosition twoSpaceFromLocation = Color == ChessColor.White ? cpm.North(oneSpaceFromLocation) : cpm.South(oneSpaceFromLocation); bool twoSpaceMoveIsLegal = !boardState.Contains(twoSpaceFromLocation); if (!HasMoved && twoSpaceMoveIsLegal) { MoveSet.Add(Color == ChessColor.White ? cpm.North(cpm.North(Location)) : cpm.South(cpm.South(Location))); } }
/// <summary> /// Is a capture legal? /// </summary> /// <returns></returns> private bool IsCaptureLegal(IPiece piece, ICapture capture, IBoardState state) { piece.GenerateCaptures(state, ActivePlayerBoardState); bool canPieceCapture = piece.CanCaptureAt(capture.EndingPosition); bool doesCaptureLeaveKingInCheck = DoesPotentialMoveLeaveKingInCheck(capture); return(canPieceCapture && !doesCaptureLeaveKingInCheck); }
private Path ValidatePathForDiscoveredCheck(IBoardState <ChessPieceEntity> boardState, Path path) { var validPath = new Path( path.Where(move => !_checkDetectionService.DoesMoveLeaveUsInCheck(boardState, move)) ); return(!validPath.Any() ? null : validPath); }
private ChessPosition GenerateCaptureWest(IBoardState enemyPieces, IChessPieceMover cpm) { ChessPosition potentialCapture = Color == ChessColor.White ? cpm.NorthWest(Location) : cpm.SouthWest(Location); bool isPieceAtCaptureLocation = enemyPieces.Contains(potentialCapture); return(isPieceAtCaptureLocation ? potentialCapture : ChessPosition.None); }
public UpdatePieceAction( IBoardEntityFactory <TEntity> entityFactory, IBoardActionProvider <TEntity> actionProvider, IBoardState <TEntity> boardState ) : base(actionProvider, boardState) { _entityFactory = entityFactory; }
private void GenerateEastMoves(IBoardState boardState, IChessPieceMover cpm) { ChessPosition nextMove = cpm.East(Location); if (!boardState.Contains(nextMove)) { MoveSet.Add(nextMove); } }
public IBoardAction Create(int moveType, IBoardState <TEntity> boardState) { if (Actions.ContainsKey(moveType)) { return(Actions[moveType](boardState)); } throw new NotImplementedException($"Action: {moveType} not implemented"); }
private void GenerateEastNorthEastMove(IBoardState boardState, IChessPieceMover cpm) { ChessPosition move = cpm.East(cpm.NorthEast(Location)); if (!boardState.Contains(move)) { MoveSet.Add(move); } }
/// <summary> /// Creates the state of the enemy board. /// </summary> /// <param name="boardState"></param> /// <param name="owningPlayerBoardState"></param> /// <returns></returns> protected IBoardState CreateEnemyBoardState(IBoardState boardState, IBoardState owningPlayerBoardState) { IBoardState state = ModelLocator.BoardState; state.Add(boardState); state.Remove(owningPlayerBoardState); return(state); }
private void GenerateSouthSouthWestMove(IBoardState boardState, IChessPieceMover cpm) { ChessPosition move = cpm.South(cpm.SouthWest(Location)); if (!boardState.Contains(move)) { MoveSet.Add(move); } }
public override void GenerateThreatened(IBoardState boardState, IBoardState owningPlayerBoardState) { IChessPieceMover cpm = ModelLocator.ChessPieceMover; ThreatenSet.Clear(); ThreatenSet.Add(GenerateThreatenedEast(cpm)); ThreatenSet.Add(GenerateThreatenedWest(cpm)); }
public Form1(IPlayerCreator playerCreator,IBoardState initialBoard) { this.initialBoard = initialBoard; squaresData = new Dictionary<int, SquareData>(); this.playerCreator = playerCreator; InitializeComponent(); depthCombo.SelectedIndex = 3; }
/// <summary> /// Is a move legal? /// </summary> /// <returns></returns> private bool IsMoveLegal(IPiece piece, IMove move, IBoardState state) { piece.GenerateMoves(state); bool canPieceMove = piece.CanMoveTo(move.EndingPosition); bool doesMoveLeaveKingInCheck = DoesPotentialMoveLeaveKingInCheck(move); return(canPieceMove && !doesMoveLeaveKingInCheck); }
/// <summary> /// /// </summary> /// <param name="boardState"></param> /// <param name="move"></param> /// <param name="performCheckTest"> /// This has a small performance impact when reverse engineering SAN from the board move /// (approx 20ms a game on my rig) which is why it's optional and defaults to off</param> /// <returns></returns> public StandardAlgebraicNotation BuildFrom(IBoardState <ChessPieceEntity> boardState, BoardMove move, bool performCheckTest = false) { var fromItem = boardState.GetItem(move.From); var piece = fromItem.Item.Piece; int?fromFile = null; int?fromRank = null; var toFile = move.To.X; var toRank = move.To.Y; var moveType = boardState.IsEmpty(move.To) ? SanMoveTypes.Move : SanMoveTypes.Take; // Are they any other pieces, // of same type as the from item // that can also move to the same location var otherPieces = boardState.GetItems() .Where(i => !i.Location.Equals(move.From)) .Where(i => i.Item.Is(fromItem.Item.Player, fromItem.Item.Piece)) .ThatCanMoveTo(move.To); // TODO: That I need this resharper disable is probably a smell // ReSharper disable PossibleMultipleEnumeration if (otherPieces.Any()) { fromFile = move.From.X; var file = fromFile; otherPieces = otherPieces .Where(i => i.Location.X == file); } if (otherPieces.Any()) { fromRank = move.From.Y; otherPieces = new List <LocatedItem <ChessPieceEntity> >(); } if (otherPieces.Any()) { Throw.InvalidSan($"Unable to disambiguate {move}"); } // ReSharper restore PossibleMultipleEnumeration if (piece == ChessPieceName.Pawn && moveType == SanMoveTypes.Take) { fromFile = fromItem.Location.X; } ChessPieceName?promotionPiece = null; if (move.ExtraData is ChessPieceEntityFactory.ChessPieceEntityFactoryTypeExtraData data) { promotionPiece = data.PieceName; } var inCheck = performCheckTest && _checkDetectionService.DoesMoveCauseCheck(boardState, move); return(new StandardAlgebraicNotation(piece, fromFile, fromRank, toFile, toRank, moveType, promotionPiece, inCheck)); }
/// <summary> /// Generates all squares that are threatened by this piece for the given boardstate. /// </summary> /// <param name="boardState">Full board state</param> /// <param name="owningPlayerBoardState">Used to ignore this other pieces of the same color.</param> public virtual void GenerateThreatened(IBoardState boardState, IBoardState owningPlayerBoardState) { ThreatenSet.Clear(); GenerateMoves(boardState); GenerateCaptures(boardState, owningPlayerBoardState); ThreatenSet.Add(MoveSet); ThreatenSet.Add(CaptureSet); }
public bool IsValidPositionForTurnOnBoard( ICellCoordinates turnPosition, IBoardState board) { var matchingTurns = this._validTurns.Where(t => { return(t.Position.Equals(turnPosition)); }); return(0 != matchingTurns.Count()); }
/// <summary> /// Constructor which perform alphabeta algorithm and set soruce ,destinationn coordinate and return captures list if exists /// </summary> /// <param name="board"></param> /// <param name="player"></param> /// <param name="depth"></param> public Move(IBoardState board, Player player, int depth) { Rules rule = new Rules(); board.Board = board.ConvertBoardStateToBoard(board); var alphaBeta = new Alphabeta(); Board temp = new Board(); var srcCoord = new Coordinate(); var destCoord = new Coordinate(); IList<Coordinate> tempCaptures = new List<Coordinate>(); if (depth%2 != 0) depth++; alphaBeta.AlphaBeta(board.Board, depth, Int32.MinValue, Int32.MaxValue, player, true, ref srcCoord, ref destCoord, ref temp, ref tempCaptures); if ((rule.InBounds(board.Board, srcCoord.X, srcCoord.Y)) && (rule.InBounds(board.Board, destCoord.X, destCoord.Y))) { board.Board = temp.Copy(); board.BoardCells = board.ConvertBoardToBoardState(board.Board); Board = board; } bool pcCaptured = tempCaptures.Count > 0; board.DrawGame = board.CheckDraw(board.Board, board.Board[destCoord.X, destCoord.Y], pcCaptured); }
/// <summary> /// Return IMove with current boardstate /// </summary> /// <param name="boardState"></param> /// <param name="depth"></param> /// <returns></returns> public IMove GetBoardMove(IBoardState boardState,int depth) { IMove move = new Move(boardState, playerColor, depth); return move; }
/// <summary> /// Convert BoardState to Board (Coordinate[]) /// </summary> /// <param name="boardState"></param> /// <returns></returns> public Board ConvertBoardStateToBoard(IBoardState boardState) { for (int i = 0; i < Board.Rows; i++) { int j = i%2 == 0 ? 7 : 6; int k=32; for (int shift=0; j >=0; k--, j -= 2, shift++) { k = (8-i)*4 - shift; Board[k].Status = boardState.BoardCells[i, j]; Board[k].X = 8 - i; Board[k].Y = j + 1; } } return Board; }
public BoardCollectionState(ILinkFactory linkFactory, IBoardState boardState) { this.linkFactory = linkFactory; this.boardState = boardState; }
private void playerVsPCToolStripMenuItem_Click(object sender, EventArgs e) { this.ChooseStartPlayer(); Player pcPlayer = this.ChoosePCPlayer(); Player userPlayer = (pcPlayer == Player.Black) ? Player.White : Player.Black; players = new Dictionary<Player, IPlayer>(); players.Add(pcPlayer, playerCreator.CreatePcPlayer(pcPlayer)); players.Add(userPlayer, new UserPlayer(userPlayer)); currBoard = initialBoard; this.PaintBoard(); // first player is the PC if (pcPlayer == player) { int depth; try { depth = int.Parse(depthCombo.Text); } catch (Exception) { depth = 4; } IMove pcMove = players[player].GetBoardMove(currBoard,depth); this.PlayMove(pcMove.Board,false); } }
public IMove GetBoardMove(IBoardState boardState,int depth) { return null; }
private void PlayMove(IBoardState newBoard,bool needToContinueEating) { currBoard = newBoard; GameState stateAfterMove = currBoard.GetGameState(player); this.PaintBoard(); if (stateAfterMove == GameState.Won) { MessageBox.Show(player.ToString()+" "+Resources.Won); players = null; return; } if (stateAfterMove == GameState.Lost) { MessageBox.Show(player.ToString() + " " + Resources.Lost); players = null; return; } if (stateAfterMove == GameState.Draw) { MessageBox.Show(Resources.Draw); players = null; return; } // check if player needs to continue eating if (needToContinueEating) { return; } // switch players if (player == Player.White) { player = Player.Black; } else { player = Player.White; } playersTurn.BackColor = this.ConvertToColor(); if (players[player] is UserPlayer) { return; } else { InteractivePause(new TimeSpan(0,0,0,0,1000)); } int depth; try { depth = int.Parse(depthCombo.Text); } catch (Exception) { depth = 4; } IMove pcMove = players[player].GetBoardMove(currBoard,depth); this.PlayMove(pcMove.Board,false); }