Esempio n. 1
0
        public void BeginGame(IUserInput whiteInput, IUserInput blackInput, IUserResponse userResponse)
        {
            SetUpChessBoard();
            var isGameComplete = false;

            var beginingTurn = new TurnResult();

            beginingTurn.Flags.Add(Flag.GameStart);
            userResponse.ReturnMoveInformation(beginingTurn, ChessBoard);

            while (!isGameComplete)
            {
                isGameComplete = WhiteTurn(whiteInput, userResponse);
                TurnCounter++;
                if (isGameComplete)
                {
                    break;
                }

                isGameComplete = BlackTurn(blackInput, userResponse);
                TurnCounter++;
                if (isGameComplete)
                {
                    break;
                }

                if (TurnCounter == 50 &&
                    ChessBoard.CapturedBlackPieces.Count == 0 &&
                    ChessBoard.CapturedWhitePieces.Count == 0)
                {
                    isGameComplete = true;
                    var result = new TurnResult();
                    result.Flags.Add(Flag.GameDraw);
                    userResponse.ReturnMoveInformation(result, ChessBoard);
                    break;
                }
            }
        }
Esempio n. 2
0
        public TurnResult MovePiece(int oldXCoordinate, int oldYCoordinate, int newXCoordinate, int newYCoordinate, IPiece piece)
        {
            IPiece pontentiallyCapturedPiece = IsPieceAt(newXCoordinate, newYCoordinate) ? PieceAt(newXCoordinate, newYCoordinate) : null;

            var turnResult = new TurnResult()
            {
                OldXCoordinate = oldXCoordinate,
                OldYCoordinate = oldYCoordinate,
                NewXCoordinate = newXCoordinate,
                NewYCoordinate = newYCoordinate,
                PieceMoved     = piece
            };

            if (IsPieceAt(newXCoordinate, newYCoordinate))
            {
                if (pieces[newXCoordinate, newYCoordinate] is King)
                {
                    turnResult.TurnCompleted           = false;
                    turnResult.ReasonForIncompleteTurn =
                        "You cannot capture a king.";
                    return(turnResult);
                }
                else
                {
                    CapturePiece(newXCoordinate, newYCoordinate);
                }
            }

            MakeMove(piece, newXCoordinate, newYCoordinate, oldXCoordinate, oldYCoordinate);

            if (!(piece is King))
            {
                var ownKing = GetOwnKing(piece.PieceColor);
                if (!IsPositionSafeForKing(ownKing, ownKing.XCoordinate, ownKing.YCoordinate))
                {
                    turnResult.TurnCompleted           = false;
                    turnResult.ReasonForIncompleteTurn =
                        "Your king is still in check.";

                    UndoMove(piece, pontentiallyCapturedPiece, newXCoordinate, newYCoordinate, oldXCoordinate, oldYCoordinate);

                    return(turnResult);
                }
            }

            var otherKing = GetOpponentKing(piece.PieceColor);

            if (!IsPositionSafeForKing(otherKing, otherKing.XCoordinate, otherKing.YCoordinate))
            {
                otherKing.IsInCheck = true;
            }
            if (otherKing.IsInCheckMate())
            {
                turnResult.Flags.Add(Flag.CheckMate);
            }
            if (otherKing.IsInStaleMate() && !IsAnyAlliesLeft(otherKing.PieceColor))
            {
                turnResult.Flags.Add(Flag.StaleMate);
            }

            ClearEnemyPawnDoubleSteps(piece.PieceColor);
            piece.HasMoved = true;

            turnResult.TurnCompleted           = true;
            turnResult.ReasonForIncompleteTurn = "";

            return(turnResult);
        }