Esempio n. 1
0
        public static void PrintChessboard(Chessboard chessboard, bool[,] possiblePositions)
        {
            ConsoleColor originBackground  = Console.BackgroundColor;
            ConsoleColor changedBackground = ConsoleColor.DarkGray;

            for (int i = 0; i < chessboard.Rows; i++)
            {
                Console.Write(8 - i + "   ");
                for (int j = 0; j < chessboard.Columns; j++)
                {
                    if (possiblePositions[i, j])
                    {
                        Console.BackgroundColor = changedBackground;
                    }
                    else
                    {
                        Console.BackgroundColor = originBackground;
                    }
                    PrintChessPiece(chessboard.ChessPiece(i, j));
                    Console.BackgroundColor = originBackground;
                }
                Console.WriteLine();
            }
            Console.WriteLine();
            Console.WriteLine("    A B C D E F G H");
            Console.BackgroundColor = originBackground;
        }
 public void DestinyPositionValidate(Position origin, Position destiny)
 {
     if (!Chessboard.ChessPiece(origin).PossibleMovement(destiny))
     {
         throw new ChessboardException("Invalid destiny position!");
     }
 }
Esempio n. 3
0
        public override bool[,] PossibleMovements()
        {
            bool[,] match = new bool[Chessboard.Rows, Chessboard.Columns];

            Position position = new Position(0, 0);

            // Up-Left
            position.SetValues(Position.Row - 1, Position.Column - 1);
            while (Chessboard.ValidPosition(position) && CanMove(position))
            {
                match[position.Row, position.Column] = true;
                if (Chessboard.ChessPiece(position) != null && Chessboard.ChessPiece(position).Color != Color)
                {
                    break;
                }
                position.SetValues(position.Row - 1, position.Column - 1);
            }

            // Up-Right
            position.SetValues(Position.Row - 1, Position.Column + 1);
            while (Chessboard.ValidPosition(position) && CanMove(position))
            {
                match[position.Row, position.Column] = true;
                if (Chessboard.ChessPiece(position) != null && Chessboard.ChessPiece(position).Color != Color)
                {
                    break;
                }
                position.SetValues(position.Row - 1, position.Column + 1);
            }

            // Down-Right
            position.SetValues(Position.Row + 1, Position.Column + 1);
            while (Chessboard.ValidPosition(position) && CanMove(position))
            {
                match[position.Row, position.Column] = true;
                if (Chessboard.ChessPiece(position) != null && Chessboard.ChessPiece(position).Color != Color)
                {
                    break;
                }
                position.SetValues(position.Row + 1, position.Column + 1);
            }

            // Down-Left
            position.SetValues(Position.Row + 1, Position.Column - 1);
            while (Chessboard.ValidPosition(position) && CanMove(position))
            {
                match[position.Row, position.Column] = true;
                if (Chessboard.ChessPiece(position) != null && Chessboard.ChessPiece(position).Color != Color)
                {
                    break;
                }
                position.SetValues(position.Row + 1, position.Column - 1);
            }

            return(match);
        }
        public void DoTheMove(Position origin, Position destiny)
        {
            ChessPiece capturedPiece = MakeTheMove(origin, destiny);

            if (IsOnCheck(CurrentPlayer))
            {
                UndoMove(origin, destiny, capturedPiece);
                throw new ChessboardException("You cannot put yourself on check!");
            }

            ChessPiece cp = Chessboard.ChessPiece(destiny);

            // #SpecialMove Promotion
            if (cp is Pawn)
            {
                if ((cp.Color == Color.White && destiny.Row == 0) || (cp.Color == Color.Black && destiny.Row == 7))
                {
                    cp = Chessboard.RemoveChessPiece(destiny);
                    ChessPieces.Remove(cp);
                    ChessPiece queen = new Queen(cp.Color, Chessboard);
                    Chessboard.ChessPiecePosition(queen, destiny);
                    ChessPieces.Add(queen);
                }
            }

            if (IsOnCheck(Opponent(CurrentPlayer)))
            {
                Check = true;
            }
            else
            {
                Check = false;
            }

            if (IsOnCheckmate(Opponent(CurrentPlayer)))
            {
                GameOver = true;
            }
            else
            {
                Turn++;
                ChangePlayer();
            }

            // #SpecialMove En Passant
            if (cp is Pawn && (destiny.Row == origin.Row - 2 || destiny.Row == origin.Row + 2))
            {
                VulnerableEnPassant = cp;
            }
            else
            {
                VulnerableEnPassant = null;
            }
        }
Esempio n. 5
0
 public static void PrintChessboard(Chessboard chessboard)
 {
     for (int i = 0; i < chessboard.Rows; i++)
     {
         Console.Write(8 - i + "   ");
         for (int j = 0; j < chessboard.Columns; j++)
         {
             PrintChessPiece(chessboard.ChessPiece(i, j));
         }
         Console.WriteLine();
     }
     Console.WriteLine();
     Console.WriteLine("    A B C D E F G H");
 }
 public void OriginPositionValidate(Position position)
 {
     if (Chessboard.ChessPiece(position) == null)
     {
         throw new ChessboardException("There is no chess piece on this position!");
     }
     if (CurrentPlayer != Chessboard.ChessPiece(position).Color)
     {
         throw new ChessboardException("The origin chess piece is not yours!");
     }
     if (!Chessboard.ChessPiece(position).IsTherePossibleMovements())
     {
         throw new ChessboardException("There is no possible movements to this origin chess piece!");
     }
 }
Esempio n. 7
0
        public override bool[,] PossibleMovements()
        {
            bool[,] match = new bool[Chessboard.Rows, Chessboard.Columns];

            Position position = new Position(0, 0);

            // Up
            position.SetValues(Position.Row - 1, Position.Column);
            if (Chessboard.ValidPosition(position) && CanMove(position))
            {
                match[position.Row, position.Column] = true;
            }

            // Diagonal Up-Right
            position.SetValues(Position.Row - 1, Position.Column + 1);
            if (Chessboard.ValidPosition(position) && CanMove(position))
            {
                match[position.Row, position.Column] = true;
            }

            // Right
            position.SetValues(Position.Row, Position.Column + 1);
            if (Chessboard.ValidPosition(position) && CanMove(position))
            {
                match[position.Row, position.Column] = true;
            }

            // Diagonal Down-Right
            position.SetValues(Position.Row + 1, Position.Column + 1);
            if (Chessboard.ValidPosition(position) && CanMove(position))
            {
                match[position.Row, position.Column] = true;
            }

            // Down
            position.SetValues(Position.Row + 1, Position.Column);
            if (Chessboard.ValidPosition(position) && CanMove(position))
            {
                match[position.Row, position.Column] = true;
            }

            // Diagonal Down-Left
            position.SetValues(Position.Row + 1, Position.Column - 1);
            if (Chessboard.ValidPosition(position) && CanMove(position))
            {
                match[position.Row, position.Column] = true;
            }

            // Left
            position.SetValues(Position.Row, Position.Column - 1);
            if (Chessboard.ValidPosition(position) && CanMove(position))
            {
                match[position.Row, position.Column] = true;
            }

            // Diagonal Up-Left
            position.SetValues(Position.Row - 1, Position.Column - 1);
            if (Chessboard.ValidPosition(position) && CanMove(position))
            {
                match[position.Row, position.Column] = true;
            }

            // #SpecialMove Castle
            if (QuantityMovements == 0 && !Game.Check)
            {
                // #SpecialMove Small Castle
                Position posR1 = new Position(Position.Row, Position.Column + 3);
                if (TestRookToCastle(posR1))
                {
                    Position p1 = new Position(Position.Row, Position.Column + 1);
                    Position p2 = new Position(Position.Row, Position.Column + 2);
                    if (Chessboard.ChessPiece(p1) == null && Chessboard.ChessPiece(p2) == null)
                    {
                        match[Position.Row, Position.Column + 2] = true;
                    }
                }
                // #SpecialMove Big Castle
                Position posR2 = new Position(Position.Row, Position.Column - 4);
                if (TestRookToCastle(posR2))
                {
                    Position p1 = new Position(Position.Row, Position.Column - 1);
                    Position p2 = new Position(Position.Row, Position.Column - 2);
                    Position p3 = new Position(Position.Row, Position.Column - 3);
                    if (Chessboard.ChessPiece(p1) == null && Chessboard.ChessPiece(p2) == null && Chessboard.ChessPiece(p3) == null)
                    {
                        match[Position.Row, Position.Column - 2] = true;
                    }
                }
            }

            return(match);
        }
Esempio n. 8
0
        private bool TestRookToCastle(Position position)
        {
            ChessPiece cp = Chessboard.ChessPiece(position);

            return(cp != null && cp is Rook && cp.Color == Color && cp.QuantityMovements == 0);
        }
Esempio n. 9
0
        private bool CanMove(Position position)
        {
            ChessPiece cp = Chessboard.ChessPiece(position);

            return(cp == null || cp.Color != Color);
        }
Esempio n. 10
0
        public override bool[,] PossibleMovements()
        {
            bool[,] match = new bool[Chessboard.Rows, Chessboard.Columns];

            Position position = new Position(0, 0);

            if (Color == Color.White)
            {
                position.SetValues(Position.Row - 1, Position.Column);
                if (Chessboard.ValidPosition(position) && Free(position))
                {
                    match[position.Row, position.Column] = true;
                }
                position.SetValues(Position.Row - 2, Position.Column);
                if (Chessboard.ValidPosition(position) && Free(position) && QuantityMovements == 0)
                {
                    match[position.Row, position.Column] = true;
                }
                position.SetValues(Position.Row - 1, Position.Column - 1);
                if (Chessboard.ValidPosition(position) && IsThereEnemy(position))
                {
                    match[position.Row, position.Column] = true;
                }
                position.SetValues(Position.Row - 1, Position.Column + 1);
                if (Chessboard.ValidPosition(position) && IsThereEnemy(position))
                {
                    match[position.Row, position.Column] = true;
                }

                // #SpecialMove En Passant
                if (Position.Row == 3)
                {
                    Position left = new Position(Position.Row, Position.Column - 1);
                    if (Chessboard.ValidPosition(left) && IsThereEnemy(left) && Chessboard.ChessPiece(left) == ChessMatch.VulnerableEnPassant)
                    {
                        match[left.Row - 1, left.Column] = true;
                    }
                    Position right = new Position(Position.Row, Position.Column + 1);
                    if (Chessboard.ValidPosition(right) && IsThereEnemy(right) && Chessboard.ChessPiece(right) == ChessMatch.VulnerableEnPassant)
                    {
                        match[right.Row - 1, right.Column] = true;
                    }
                }
            }
            else
            {
                position.SetValues(Position.Row + 1, Position.Column);
                if (Chessboard.ValidPosition(position) && Free(position))
                {
                    match[position.Row, position.Column] = true;
                }
                position.SetValues(Position.Row + 2, Position.Column);
                if (Chessboard.ValidPosition(position) && Free(position) && QuantityMovements == 0)
                {
                    match[position.Row, position.Column] = true;
                }
                position.SetValues(Position.Row + 1, Position.Column - 1);
                if (Chessboard.ValidPosition(position) && IsThereEnemy(position))
                {
                    match[position.Row, position.Column] = true;
                }
                position.SetValues(Position.Row + 1, Position.Column + 1);
                if (Chessboard.ValidPosition(position) && IsThereEnemy(position))
                {
                    match[position.Row, position.Column] = true;
                }

                // #SpecialMove En Passant
                if (Position.Row == 4)
                {
                    Position left = new Position(Position.Row, Position.Column - 1);
                    if (Chessboard.ValidPosition(left) && IsThereEnemy(left) && Chessboard.ChessPiece(left) == ChessMatch.VulnerableEnPassant)
                    {
                        match[left.Row + 1, left.Column] = true;
                    }
                    Position right = new Position(Position.Row, Position.Column + 1);
                    if (Chessboard.ValidPosition(right) && IsThereEnemy(right) && Chessboard.ChessPiece(right) == ChessMatch.VulnerableEnPassant)
                    {
                        match[right.Row + 1, right.Column] = true;
                    }
                }
            }
            return(match);
        }
Esempio n. 11
0
 private bool Free(Position position)
 {
     return(Chessboard.ChessPiece(position) == null);
 }
Esempio n. 12
0
        private bool IsThereEnemy(Position position)
        {
            ChessPiece cp = Chessboard.ChessPiece(position);

            return(cp != null && cp.Color != Color);
        }