Exemplo n.º 1
0
        public Brain(StaticEvaluator staticEvaluator)
        {
            _StaticEvaluator = staticEvaluator;

            for (int i = 0; i < _PlyInfo.Length; i++)
            {
                _PlyInfo[i] = new PlyInfo();
            }
        }
Exemplo n.º 2
0
        public void AddPosition(Board board, Move bestMove, int score, int searchDepth, int currentPly, Sides currentSide, HashEntryTypes type)
        {
            score = StaticEvaluator.RemovePlyDependence(score);

            UInt64 hashKey = currentSide == Sides.White ? board.HashKey : ~board.HashKey;

            UInt64 globalTableIndex = hashKey % (UInt64)_GlobalTable.Length;
            UInt64 localTableIndex  = hashKey % (UInt64)_LocalTable.Length;

            HashEntry globalEntry = _GlobalTable[globalTableIndex];

            if (globalEntry.IsStale)
            {
                _GlobalTable[globalTableIndex] = new HashEntry(hashKey, bestMove, score, searchDepth, type);
            }
            else
            {
                bool isMoreValuable = searchDepth > globalEntry.SearchDepth ||
                                      searchDepth == globalEntry.SearchDepth && type == HashEntryTypes.Exact;

                if (globalEntry.HashKey == hashKey)
                {
                    bool improvesBound = searchDepth == globalEntry.SearchDepth &&
                                         (type == HashEntryTypes.LowerBound && globalEntry.Type == HashEntryTypes.LowerBound && score > globalEntry.Score ||
                                          type == HashEntryTypes.UpperBound && globalEntry.Type == HashEntryTypes.LowerBound && score < globalEntry.Score);

                    if (isMoreValuable || improvesBound)
                    {
                        _GlobalTable[globalTableIndex] = new HashEntry(hashKey, bestMove, score, searchDepth, type);
                    }
                }
                else
                {
                    if (isMoreValuable)
                    {
                        _GlobalTable[globalTableIndex] = new HashEntry(hashKey, bestMove, score, searchDepth, type);
                        _LocalTable[localTableIndex]   = globalEntry;
                    }
                    else
                    {
                        _LocalTable[localTableIndex] = new HashEntry(hashKey, bestMove, score, searchDepth, type);
                    }
                }
            }
        }
Exemplo n.º 3
0
        HashEntryTypes LookupPosition(HashEntry[] table, UInt64 hashKey, int desiredDepth, int currentPly, Sides currentSide, ref int alpha, ref int beta)
        {
            UInt64 tableIndex = hashKey % (UInt64)table.Length;

            if (table[tableIndex].HashKey == hashKey)
            {
                table[tableIndex].IsStale = false;

                int score = StaticEvaluator.AddPlyDependence(table[tableIndex].Score, currentPly);

                if (table[tableIndex].SearchDepth < desiredDepth)
                {
                    return(HashEntryTypes.Junk);
                }

                switch (table[tableIndex].Type)
                {
                case HashEntryTypes.LowerBound:
                    if (score >= beta)
                    {
                        beta = score;
                        return(HashEntryTypes.LowerBound);
                    }
                    break;

                case HashEntryTypes.Exact:
                    alpha = score;
                    return(HashEntryTypes.Exact);

                case HashEntryTypes.UpperBound:
                    if (score <= alpha)
                    {
                        alpha = score;
                        return(HashEntryTypes.UpperBound);
                    }
                    break;
                }
            }

            return(HashEntryTypes.Junk);
        }
Exemplo n.º 4
0
        protected override void AnalyzeOurBoard()
        {
            _NodesEvaluated = 0;

            _TranspositionTable.SetStale();

            int depth = 2;
            int score = 0;

            while (true)
            {
                score = Search(depth, score);

                if (!_AreWeThinking)
                {
                    break;
                }

                _Score    = score;
                _BestMove = _PlyInfo[0].PrincipalVariation[0];

                _PrincipalVariation.Clear();
                for (int i = 0; i < _PlyInfo[0].PrincipalVariationLength; i++)
                {
                    _PrincipalVariation.Add(_PlyInfo[0].PrincipalVariation[i]);
                }

                ReportSearchInformation(depth);

                if (StaticEvaluator.IsMate(_Score))
                {
                    break;
                }

                StuffPrincipalVariationIntoTranspositionTable(0, _OurSide, depth);

                depth++;
            }
        }
Exemplo n.º 5
0
        protected int AlphaBetaSearch(int alpha, int beta, int remainingDepth, int currentPly, Sides currentSide)
        {
            _NodesEvaluated++;

            _PlyInfo[currentPly].PrincipalVariationLength = currentPly;

            if (currentPly >= PlyInfo.MaxPly)
            {
                return(beta);
            }

            switch (_TranspositionTable.LookupPosition(_ScratchBoard, remainingDepth, currentPly, currentSide, ref alpha, ref beta))
            {
            case HashEntryTypes.LowerBound:
                return(beta);

            case HashEntryTypes.Exact:
                Move transpositionTableMove = _TranspositionTable.GetBestMove(_ScratchBoard, currentSide);
                if (!transpositionTableMove.Equals(Move.Empty))
                {
                    UpdatePrincipalVariation(transpositionTableMove, currentPly);
                }

                return(alpha);

            case HashEntryTypes.UpperBound:
                return(alpha);
            }

            if (remainingDepth <= 0)
            {
                return(QuiescenceSearch(alpha, beta, currentPly, currentSide));
            }

            int pruneScore;

            if (CanPrune(alpha, beta, remainingDepth, currentPly, currentSide, out pruneScore))
            {
                return(pruneScore);
            }

            List <Move> moves;

            if (GenerateMoves(currentPly, currentSide, out moves) == MoveGenerationResults.Mated)
            {
                int mateScore = -StaticEvaluator.MateScoreFromPly(currentPly);
                _TranspositionTable.AddPosition(_ScratchBoard, Move.Empty,
                                                mateScore, remainingDepth, currentPly, currentSide, HashEntryTypes.Exact);

                return(mateScore);
            }

            _PlyInfo[currentPly].Board.CopyFrom(_ScratchBoard);

            int originalAlpha = alpha;

            foreach (Move move in moves)
            {
                if (!_AreWeThinking)
                {
                    return(alpha);
                }

                if (_ScratchBoard.MakeMove(move) == MakeMoveResults.UndoMove)
                {
                    UndoMove(currentPly);
                    continue;
                }

                int score = -AlphaBetaSearch(-beta, -alpha, remainingDepth - 1, currentPly + 1, Board.OtherSide(currentSide));

                UndoMove(currentPly);

                if (score >= beta)
                {
                    SetKiller(move, currentPly);

                    _TranspositionTable.AddPosition(_ScratchBoard, move, score,
                                                    remainingDepth, currentPly, currentSide, HashEntryTypes.LowerBound);

                    return(score);
                }

                if (score > alpha)
                {
                    alpha = score;

                    UpdatePrincipalVariation(move, currentPly);
                }
            }

            if (alpha == originalAlpha)
            {
                _TranspositionTable.AddPosition(_ScratchBoard, Move.Empty,
                                                alpha, remainingDepth, currentPly, currentSide, HashEntryTypes.UpperBound);
            }
            else
            {
                SetKiller(_PlyInfo[currentPly].PrincipalVariation[currentPly], currentPly);

                _TranspositionTable.AddPosition(_ScratchBoard, _PlyInfo[currentPly].PrincipalVariation[currentPly],
                                                alpha, remainingDepth, currentPly, currentSide, HashEntryTypes.Exact);
            }

            return(alpha);
        }
Exemplo n.º 6
0
 public BasicAlphaBetaBrain(StaticEvaluator staticEvaluator, int memoryCapacity_MB)
     : base(staticEvaluator, memoryCapacity_MB)
 {
 }
Exemplo n.º 7
0
 public NullMoveBrain(StaticEvaluator staticEvaluator, int memoryCapacity_MB)
     : base(staticEvaluator, memoryCapacity_MB)
 {
 }
Exemplo n.º 8
0
 public MTDfBrain(StaticEvaluator staticEvaluator, int memoryCapacity_MB)
     : base(staticEvaluator, memoryCapacity_MB)
 {
 }
Exemplo n.º 9
0
 public TranspositionTableBrain(StaticEvaluator staticEvaluator, int memoryCapacity_MB)
     : base(staticEvaluator)
 {
     _TranspositionTable = new TranspositionTable(memoryCapacity_MB * 1024 * 1024);
 }