Beispiel #1
0
        int HarmlessPruning(int height)
        {
            if (HalfMoveClock >= 120)
            {
                return(0);
            }
            RepititionResult rep = Repitition();

            if (rep != RepititionResult.NONE)
            {
                return((int)rep);
            }

            return(-G.MATE + height - 1);
        }
Beispiel #2
0
        //http://blog.sina.com.cn/s/blog_5fd97aa90100vq5p.html
        public RepititionResult RuleTest(string filename)
        {
            Debug.Assert(filename != null);
            PgnFileStruct pgn = ReadPgnFile(filename);

            FromFEN(pgn.StartFEN);
            foreach (MOVE mv in pgn.MoveList)
            {
                Console.WriteLine(mv);
                MakeMove(mv, true);
                RepititionResult rep = Repitition();
                switch (rep)
                {
                case RepititionResult.WIN:
                    if (sdPlayer == 0)
                    {
                        Console.WriteLine("黑方负");
                    }
                    else
                    {
                        Console.WriteLine("红方负");
                    }
                    break;

                case RepititionResult.LOSE:
                    if (sdPlayer == 0)
                    {
                        Console.WriteLine("黑方胜");
                    }
                    else
                    {
                        Console.WriteLine("红方胜");
                    }
                    break;

                case RepititionResult.DRAW:
                    Console.WriteLine("不变作和");
                    break;

                default:
                    break;
                }
            }
            return(RepititionResult.NONE);
        }
Beispiel #3
0
        public int SearchQuiesce(int alpha, int beta, int qheight, int height)
        {
            beta = Math.Min(beta, G.WIN);
            stat.QuiesceNodes++;
            MOVE mvLast    = stepList[stepList.Count - 1].move;
            bool isChecked = mvLast.checking;
            int  best;
            IEnumerable <MOVE> moves;

            //偶数层是主动方,奇数层是被动方
            TransKiller = null;
            if (qheight % 2 == 0)
            {
                if (isChecked)
                {
                    best  = -G.MATE + height - 1;
                    moves = GetNextMove(7, height);
                }
                else
                {
                    best  = Simple_Evaluate();
                    moves = GetNextMove(3, height);

                    if (best > beta && mvLast.pcDst == 0 && stepList[stepList.Count - 2].move.pcDst == 0)
                    {
                        stat.BetaCutoffs++;
                        return(best);
                    }
                    if (qheight > G.MAX_QUEISCE_DEPTH && mvLast.pcDst == 0)
                    {
                        return(best);
                    }
                    if (best > alpha)
                    {
                        alpha = best;
                    }
                }
            }
            else
            {
                if (isChecked)    //避免长照
                {
                    RepititionResult rep = Repitition();
                    if (rep != RepititionResult.NONE)
                    {
                        return((int)rep);
                    }
                    best = height - G.MATE - 1;
                }
                else
                {
                    best = Simple_Evaluate();
                    if (best > beta && mvLast.pcDst == 0 && stepList[stepList.Count - 2].move.pcDst == 0)
                    {
                        stat.BetaCutoffs++;
                        return(best);
                    }
                    if (best > alpha)
                    {
                        alpha = best;
                    }
                }
                //only extend evade and re-capture
                if (isChecked)
                {
                    moves = GetNextMove(7, height);
                }
                else
                {
                    moves = GetNextMove(2, height);
                }
            }
            int vl;

            foreach (MOVE mv in moves)
            {
                //if (!isChecked && height >= RootDepth * 2 && mv.pcDst == 0)
                //    continue;
                Debug.Write(new string('\t', height));
                Debug.WriteLine($"{mv} {alpha}, {beta}, {best}, {height}");
                MakeMove(mv, false);
                if (qheight % 2 == 0)
                {
                    if (stepList[stepList.Count - 1].move.checking)
                    {
                        stat.CheckExtesions++;
                    }
                    else
                    {
                        stat.CaptureExtensions++;
                    }
                }
                vl = -SearchQuiesce(-beta, -alpha, qheight + 1, height + 1);
                UnmakeMove();
                if (vl >= beta)
                {
                    stat.BetaCutoffs++;
                    SetBestMove(mv, vl, 0, height);
                    return(vl);
                }
                if (vl >= best)
                {
                    best  = vl;
                    alpha = Math.Max(alpha, vl);
                }
            }
            return(best);
        }