Example #1
0
        public static bool rules(Point piece, Point destination, GameState gs, MinimaxBoardLogic logic)
        {
            int xDistance = Math.Abs(piece.X - destination.X);
            int yDistance = Math.Abs(piece.Y - destination.Y);

            if (gs.state[piece].firstMove == true)
            {
                Point tempKingPoint = new Point('e', piece.Y);

                if (destination.X == tempKingPoint.X && destination.Y == tempKingPoint.Y)
                {
                    Piece tempKingPiece = gs.state[tempKingPoint];

                    if (tempKingPiece.type == PieceType.King && tempKingPiece.colour == gs.state[piece].colour &&
                        IterationCheck.isNoPieceBetweenLinear(piece, tempKingPoint, gs) && tempKingPiece.firstMove == true)
                    {
                        logic.castling = true;
                        return(true);
                    }
                }
            }

            if (xDistance != 0 && yDistance != 0)
            {
                return(false);
            }
            else if (xDistance > 0 && yDistance > 0)
            {
                return(false);
            }
            else if (xDistance > 0 || yDistance > 0)
            {
                if (!IterationCheck.isNoPieceBetweenLinear(piece, destination, gs))
                {
                    return(false);
                }
            }

            return(true);
        }
Example #2
0
        public static bool rules(Point piece, Point destination, bool from1to8, GameState gs, MinimaxBoardLogic logic, bool?computerPawnPromotion = false)
        {
            int  xDistance      = Math.Abs(piece.X - destination.X);
            int  yDistance      = piece.Y - destination.Y;
            bool pawnsFirstMove = gs.state[piece].firstMove;

            if (from1to8)
            {
                if (yDistance != -1 && yDistance != -2)
                {
                    return(false);
                }
                else if (yDistance == -2 && !pawnsFirstMove)
                {
                    return(false);
                }
                else if (!IterationCheck.isNoPieceBetweenLinear(piece, destination, gs))
                {
                    return(false);
                }
            }
            else
            {
                if (yDistance != 1 && yDistance != 2)
                {
                    return(false);
                }
                else if (yDistance == 2 && !pawnsFirstMove)
                {
                    return(false);
                }
                else if (!IterationCheck.isNoPieceBetweenLinear(piece, destination, gs))
                {
                    return(false);
                }
            }

            if (xDistance != 0 && xDistance != 1)
            {
                return(false);
            }
            else if (xDistance == 0 && gs.state[destination].type != PieceType.Blank)
            {
                return(false);
            }
            else if (xDistance == 1 && gs.state[destination].type == PieceType.Blank &&
                     gs.state[new Point(destination.X, piece.Y)].type != PieceType.Pawn)
            {
                return(false);
            }
            else if (xDistance == 1 && gs.state[destination].type == PieceType.Blank &&
                     gs.state[new Point(destination.X, piece.Y)].type == PieceType.Pawn &&
                     gs.state[new Point(destination.X, piece.Y)].pawnDoubleSpace == false) // En passant
            {
                return(false);
            }

            if (Math.Abs(yDistance) == 2)
            {
                gs.state[piece].pawnDoubleSpace = true;
            }

            if (xDistance == 1 && gs.state[destination].type == PieceType.Blank &&
                gs.state[new Point(destination.X, piece.Y)].type == PieceType.Pawn &&
                gs.state[new Point(destination.X, piece.Y)].colour != gs.state[piece].colour &&
                gs.state[new Point(destination.X, piece.Y)].pawnDoubleSpace == true)
            {
                logic.enPassant = true;
            }

            if (((from1to8 && (destination.Y == 8)) ||
                 (!from1to8 && (destination.Y == 1))))
            {
                char inputChar;
                bool promotionCompleted = false;

                while (!promotionCompleted)
                {
                    if (!computerPawnPromotion.Value)
                    {
                        Console.WriteLine("Pawn promotion! Please select a new peice:");
                        inputChar = char.ToLower(Console.ReadKey().KeyChar);
                    }
                    else
                    {
                        inputChar = 'q';
                    }

                    switch (inputChar)
                    {
                    case 'q':
                        gs.state[piece].type = PieceType.Queen;
                        promotionCompleted   = true;
                        break;

                    case 'r':
                        gs.state[piece].type = PieceType.Rook;
                        promotionCompleted   = true;
                        break;

                    case 'n':
                        gs.state[piece].type = PieceType.Knight;
                        promotionCompleted   = true;
                        break;

                    case 'b':
                        gs.state[piece].type = PieceType.Bishop;
                        promotionCompleted   = true;
                        break;

                    default:
                        Console.WriteLine("Incorrect entry - please enter what new piece you would like (q, r, n, b)");
                        break;
                    }
                }
            }

            return(true);
        }