Пример #1
0
        private static ResultBoards GetSortValidMoves(Board examineBoard)
        {
            ResultBoards resultBoards = new ResultBoards()
            {
                Positions = new List <Board>(30)
            };

            Search.piecesRemaining = 0;
            for (byte srcPosition = 0; (int)srcPosition < 64; ++srcPosition)
            {
                Square square = examineBoard.Squares[(int)srcPosition];
                if (square.Piece != null)
                {
                    ++Search.piecesRemaining;
                    if (square.Piece.PieceColor == examineBoard.WhoseMove)
                    {
                        foreach (byte validMove in square.Piece.ValidMoves)
                        {
                            Board board = examineBoard.FastCopy();
                            Board.MovePiece(board, srcPosition, validMove, ChessPieceType.Queen);
                            PieceValidMoves.GenerateValidMoves(board);
                            if ((!board.WhiteCheck || examineBoard.WhoseMove != ChessPieceColor.White) && (!board.BlackCheck || examineBoard.WhoseMove != ChessPieceColor.Black))
                            {
                                Evaluation.EvaluateBoardScore(board);
                                board.Score = Search.SideToMoveScore(board.Score, board.WhoseMove);
                                resultBoards.Positions.Add(board);
                            }
                        }
                    }
                }
            }
            resultBoards.Positions.Sort(new Comparison <Board>(Search.Sort));
            return(resultBoards);
        }
Пример #2
0
        private static int Quiescence(Board examineBoard, int alpha, int beta, ref int nodesSearched)
        {
            nodesSearched = nodesSearched + 1;
            Evaluation.EvaluateBoardScore(examineBoard);
            examineBoard.Score = Search.SideToMoveScore(examineBoard.Score, examineBoard.WhoseMove);
            if (examineBoard.Score >= beta)
            {
                return(beta);
            }
            if (examineBoard.Score > alpha)
            {
                alpha = examineBoard.Score;
            }
            List <Search.Position> positionList = examineBoard.WhiteCheck || examineBoard.BlackCheck ? Search.EvaluateMoves(examineBoard, (byte)0) : Search.EvaluateMovesQ(examineBoard);

            if (positionList.Count == 0)
            {
                return(examineBoard.Score);
            }
            positionList.Sort(new Comparison <Search.Position>(Search.Sort));
            foreach (Search.Position position in positionList)
            {
                if (Search.StaticExchangeEvaluation(examineBoard.Squares[(int)position.DstPosition]) < 0)
                {
                    Board board = examineBoard.FastCopy();
                    Board.MovePiece(board, position.SrcPosition, position.DstPosition, ChessPieceType.Queen);
                    PieceValidMoves.GenerateValidMoves(board);
                    if ((!board.BlackCheck || examineBoard.WhoseMove != ChessPieceColor.Black) && (!board.WhiteCheck || examineBoard.WhoseMove != ChessPieceColor.White))
                    {
                        int num = -Search.Quiescence(board, -beta, -alpha, ref nodesSearched);
                        if (num >= beta)
                        {
                            Search.KillerMove[2, 0].SrcPosition = position.SrcPosition;
                            Search.KillerMove[2, 0].DstPosition = position.DstPosition;
                            return(beta);
                        }
                        if (num > alpha)
                        {
                            alpha = num;
                        }
                    }
                }
            }
            return(alpha);
        }