示例#1
0
        // ThreadsManager::start_searching() wakes up the main thread sleeping in
        // main_loop() so to start a new search, then returns immediately.
        internal static void start_searching(Position pos, LimitsType limits, List <Move> searchMoves)
        {
            wait_for_search_finished();

            Search.SearchTime.Reset(); Search.SearchTime.Start(); // As early as possible

            Search.SignalsStopOnPonderhit = Search.SignalsFirstRootMove = false;
            Search.SignalsStop            = Search.SignalsFailedLowAtRoot = false;

            Search.RootPosition.copy(pos);
            Search.Limits = limits;
            Search.RootMoves.Clear();

            MList mlist = MListBroker.GetObject(); mlist.pos = 0;

            Movegen.generate_legal(pos, mlist.moves, ref mlist.pos);
            for (int i = 0; i < mlist.pos; i++)
            {
                Move move = mlist.moves[i].move;
                if ((searchMoves.Count == 0) || Utils.existSearchMove(searchMoves, move))
                {
                    Search.RootMoves.Add(new RootMove(move));
                }
            }
            MListBroker.Free();

            main_thread().do_sleep = false;
            main_thread().wake_up();
        }
示例#2
0
        /// Mate with KX vs K. This function is used to evaluate positions with
        /// King and plenty of material vs a lone king. It simply gives the
        /// attacking side a bonus for driving the defending king towards the edge
        /// of the board, and for keeping the distance between the two kings small.
        /// KXK
        internal static Value Endgame_KXK(Color strongerSide, Position pos)
        {
            Color weakerSide = strongerSide ^ 1;

            Debug.Assert(pos.non_pawn_material(weakerSide) == ValueC.VALUE_ZERO);
            Debug.Assert(pos.piece_count(weakerSide, PieceTypeC.PAWN) == ValueC.VALUE_ZERO);

            // Stalemate detection with lone king
            MList mlist = MListBroker.GetObject(); mlist.pos = 0;
            Movegen.generate_legal(pos, mlist.moves, ref mlist.pos);
            bool any = mlist.pos > 0;
            MListBroker.Free();

            if (pos.sideToMove == weakerSide
                && !pos.in_check()
                && !any)
            {
                return ValueC.VALUE_DRAW;
            }

            Square winnerKSq = pos.king_square(strongerSide);
            Square loserKSq = pos.king_square(weakerSide);

            Value result = pos.non_pawn_material(strongerSide)
                           + pos.piece_count(strongerSide, PieceTypeC.PAWN) * Constants.PawnValueEndgame
                           + MateTable[loserKSq]
                           + DistanceBonus[Utils.square_distance(winnerKSq, loserKSq)];

            if (pos.piece_count(strongerSide, PieceTypeC.QUEEN)!=0
            || pos.piece_count(strongerSide, PieceTypeC.ROOK)!=0
            || pos.bishop_pair(strongerSide))
            {

                result += ValueC.VALUE_KNOWN_WIN;
            }

            return strongerSide == pos.sideToMove ? result : -result;
        }
示例#3
0
        /// Book::probe() tries to find a book move for the given position. If no move
        /// is found returns MOVE_NONE. If pickBest is true returns always the highest
        /// rated move, otherwise randomly chooses one, based on the move score.
        internal static Move probe(Position pos, string filename, bool pickBest)
        {
#if PORTABLE
            #region DLL book

            if (bookNotExists)
            {
                return(MoveC.MOVE_NONE);
            }

            BookEntry e    = new BookEntry();
            UInt16    best = 0;
            uint      sum  = 0;
            Move      move = MoveC.MOVE_NONE;
            UInt64    key  = book_key(pos);

            try
            {
                System.Reflection.Assembly bookAssembly = System.Reflection.Assembly.Load("PortfishBook");
                using (Stream fs = bookAssembly.GetManifestResourceStream("PortfishBook.book.bin"))
                {
                    UInt64 size = (UInt64)(fs.Length / SIZE_OF_BOOKENTRY);
                    using (BinaryReader br = new BinaryReader(fs))
                    {
                        binary_search(key, size, br);
                        while (Read(ref e, br) && (e.key == key))
                        {
                            best = Math.Max(best, e.count);
                            sum += e.count;

                            // Choose book move according to its score. If a move has a very
                            // high score it has higher probability to be choosen than a move
                            // with lower score. Note that first entry is always chosen.
                            if ((RKiss.rand() % sum < e.count) ||
                                (pickBest && e.count == best))
                            {
                                move = e.move;
                            }
                        }
                    }
                }
            }
            catch (System.IO.FileNotFoundException)
            {
                bookNotExists = true;
                return(MoveC.MOVE_NONE);
            }

            #endregion
#else
            #region File system read

            if (!System.IO.File.Exists(filename))
            {
                return(MoveC.MOVE_NONE);
            }

            BookEntry e    = new BookEntry();
            UInt16    best = 0;
            uint      sum  = 0;
            Move      move = MoveC.MOVE_NONE;
            UInt64    key  = book_key(pos);

            using (FileStream fs = new FileStream(filename, FileMode.Open))
            {
                UInt64 size = (UInt64)(fs.Length / SIZE_OF_BOOKENTRY);
                using (BinaryReader br = new BinaryReader(fs))
                {
                    binary_search(key, size, br);
                    while (Read(ref e, br) && (e.key == key))
                    {
                        best = Math.Max(best, e.count);
                        sum += e.count;

                        // Choose book move according to its score. If a move has a very
                        // high score it has higher probability to be choosen than a move
                        // with lower score. Note that first entry is always chosen.
                        if (((sum != 0) && (RKiss.rand() % sum < e.count)) ||
                            (pickBest && e.count == best))
                        {
                            move = e.move;
                        }
                    }
                    br.Close();
                }
                fs.Close();
            }

            #endregion
#endif

            if (move != 0)
            {
                // A PolyGlot book move is encoded as follows:
                //
                // bit  0- 5: destination square (from 0 to 63)
                // bit  6-11: origin square (from 0 to 63)
                // bit 12-14: promotion piece (from KNIGHT == 1 to QUEEN == 4)
                //
                // Castling moves follow "king captures rook" representation. So in case book
                // move is a promotion we have to convert to our representation, in all the
                // other cases we can directly compare with a Move after having masked out
                // the special Move's flags (bit 14-15) that are not supported by PolyGlot.
                int pt = (move >> 12) & 7;
                if (pt != 0)
                {
                    move = Utils.make_promotion(Utils.from_sq(move), Utils.to_sq(move), (pt + 1));
                }

                // Add 'special move' flags and verify it is legal
                MList mlist = MListBroker.GetObject(); mlist.pos = 0;
                Movegen.generate_legal(pos, mlist.moves, ref mlist.pos);
                for (int i = 0; i < mlist.pos; i++)
                {
                    if (move == (mlist.moves[i].move & 0x3FFF))
                    {
                        Move retval = mlist.moves[i].move;
                        MListBroker.Free();
                        return(retval);
                    }
                }
                MListBroker.Free();
            }

            return(MoveC.MOVE_NONE);
        }
示例#4
0
        /// MovePicker::generate_next() generates, scores and sorts the next bunch of moves,
        /// when there are no more moves to try for the current phase.
        private void generate_next()
        {
            curMovePos = 0;

            switch (++phase)
            {
            case SequencerC.CAPTURES_S1:
            case SequencerC.CAPTURES_S3:
            case SequencerC.CAPTURES_S4:
            case SequencerC.CAPTURES_S5:
            case SequencerC.CAPTURES_S6:
                mpos = 0;
                Movegen.generate_capture(pos, ms, ref mpos);
                lastMovePos = mpos;
                score_captures();
                return;

            case SequencerC.KILLERS_S1:
                curMovePos  = Constants.MAX_MOVES;   //killers[0];
                lastMovePos = curMovePos + 2;
                return;

            case SequencerC.QUIETS_1_S1:
                mpos = 0;
                Movegen.generate_quiet(pos, ms, ref mpos);
                lastQuietPos = lastMovePos = mpos;
                score_noncaptures();
                lastMovePos = partition(curMovePos, lastMovePos);
                sort();
                return;

            case SequencerC.QUIETS_2_S1:
                curMovePos  = lastMovePos;
                lastMovePos = lastQuietPos;
                if (depth >= 3 * DepthC.ONE_PLY)
                {
                    sort();
                }
                return;

            case SequencerC.BAD_CAPTURES_S1:
                // Just pick them in reverse order to get MVV/LVA ordering
                curMovePos  = Constants.MAX_MOVES - 1;
                lastMovePos = lastBadCapturePos;
                return;

            case SequencerC.EVASIONS_S2:
                mpos = 0;
                Movegen.generate_evasion(pos, ms, ref mpos);
                lastMovePos = mpos;
                score_evasions();
                return;

            case SequencerC.QUIET_CHECKS_S3:
                mpos = 0;
                Movegen.generate_quiet_check(pos, ms, ref mpos);
                lastMovePos = mpos;
                return;

            case SequencerC.EVASION:
            case SequencerC.QSEARCH_0:
            case SequencerC.QSEARCH_1:
            case SequencerC.PROBCUT:
            case SequencerC.RECAPTURE:
                phase       = SequencerC.STOP;
                lastMovePos = curMovePos + 1;     // Avoid another next_phase() call
                break;

            case SequencerC.STOP:
                lastMovePos = curMovePos + 1;     // Avoid another next_phase() call
                return;

            default:
                Debug.Assert(false);
                break;
            }
        }