Esempio n. 1
0
        public void RecordHash(ZobristHash hash, QuiescentFlag flag, int score)
        {
            if (!m_closed)
            {
                int i = CalculateHashIndex(hash);

                m_hashTable[i].Hash.Key  = hash.Key;
                m_hashTable[i].Hash.Lock = hash.Lock;
                m_hashTable[i].Flag      = flag;
                m_hashTable[i].Score     = score;
            }
        }
Esempio n. 2
0
        public void RecordHash(ZobristHash hash, QuiescentFlag flag, int score)
        {
            if (!m_closed)
              {
            int i = CalculateHashIndex(hash);

            m_hashTable[i].Hash.Key = hash.Key;
            m_hashTable[i].Hash.Lock = hash.Lock;
            m_hashTable[i].Flag = flag;
            m_hashTable[i].Score = score;
              }
        }
Esempio n. 3
0
        /// <summary>
        /// Carries out a narrow Quiescent search where only capure moves are searched.
        /// </summary>
        /// <param name="alpha">Current alpha value.</param>
        /// <param name="beta">Current beta value.</param>
        /// <returns>The score of a board.</returns>
        private int QuiescentSearch(int alpha, int beta)
        {
            if (m_searchRollback)
            {
                return(beta);
            }

            //At interval check if time is up and rollback if so.
            if (m_nodesVisited == m_nextRollbackCheck)
            {
                if (AbortingSearch())
                {
                    m_alphaBetaTable.Close();
                    m_quiescentTable.Close();
                    m_searchRollback = true;
                    return(beta);
                }

                m_nextRollbackCheck += ROLLBACK_INTERVAL_COUNT;
            }
            ++m_nodesVisited;

            int           score         = 0;
            QuiescentFlag quiescentFlag = QuiescentFlag.AlphaScore;

            if (m_quiescentTable.ProbeScore(m_board.BoardHash(false), alpha, beta, ref score))
            {
                return(score);
            }

            score = m_evaluator.EvaluatePosition(m_board);

            if (score >= beta)
            {
                m_quiescentTable.RecordHash(m_board.BoardHash(false), QuiescentFlag.BetaScore, beta);
                return(beta);
            }

            if (score > alpha)
            {
                alpha         = score;
                quiescentFlag = QuiescentFlag.ExactScore;
            }

            MoveOrganizer currentMoves = new MoveOrganizer();

            m_board.GeneratePseudoLegalMoves(currentMoves);
            currentMoves.Sort(m_captureMoveCompare);

            foreach (Move move in currentMoves)
            {
                if (!move.IsCaptureMove)
                {
                    break;
                }

                if (move.Execute(m_board))
                {
                    score = -QuiescentSearch(-beta, -alpha);
                    move.UnExecute(m_board);

                    if (score >= beta)
                    {
                        m_quiescentTable.RecordHash(m_board.BoardHash(false), QuiescentFlag.BetaScore, beta);
                        return(beta);
                    }

                    if (score > alpha)
                    {
                        alpha         = score;
                        quiescentFlag = QuiescentFlag.ExactScore;
                    }
                }
            }

            m_quiescentTable.RecordHash(m_board.BoardHash(false), quiescentFlag, alpha);
            return(alpha);
        }